X-Git-Url: https://git.wh0rd.org/?p=ICEs.git;a=blobdiff_plain;f=462550%2Fbug462550.ii.0;fp=462550%2Fbug462550.ii.0;h=b34b125ff82d26caa00d8964ee3c41250575558f;hp=0000000000000000000000000000000000000000;hb=bd3239d2bbe0de3a200b266503e3330b1e391489;hpb=dbff64cb4b7530861c2309c794efdd4e0cf47a23

diff --git a/462550/bug462550.ii.0 b/462550/bug462550.ii.0
new file mode 100644
index 0000000..b34b125
--- /dev/null
+++ b/462550/bug462550.ii.0
@@ -0,0 +1,145854 @@
+namespace std
+{
+  typedef long unsigned int size_t;
+  typedef long int ptrdiff_t;
+}
+namespace std
+{
+  inline namespace __gnu_cxx_ldbl128 { }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Alloc>
+    class allocator;
+  template<class _CharT>
+    struct char_traits;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+  template<> struct char_traits<char>;
+  typedef basic_string<char> string;
+  template<> struct char_traits<wchar_t>;
+  typedef basic_string<wchar_t> wstring;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  struct __true_type { };
+  struct __false_type { };
+  template<bool>
+    struct __truth_type
+    { typedef __false_type __type; };
+  template<>
+    struct __truth_type<true>
+    { typedef __true_type __type; };
+  template<class _Sp, class _Tp>
+    struct __traitor
+    {
+      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+      typedef typename __truth_type<__value>::__type __type;
+    };
+  template<typename, typename>
+    struct __are_same
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Tp>
+    struct __are_same<_Tp, _Tp>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_void
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_void<void>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_integer<bool>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_floating
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_floating<float>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_floating<double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_floating<long double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_pointer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Tp>
+    struct __is_pointer<_Tp*>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_normal_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Iterator, typename _Container>
+    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
+             _Container> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_arithmetic
+    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+    { };
+  template<typename _Tp>
+    struct __is_fundamental
+    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
+    { };
+  template<typename _Tp>
+    struct __is_scalar
+    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+    { };
+  template<typename _Tp>
+    struct __is_char
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_char<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_char<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_byte
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_byte<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_byte<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_byte<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  template<bool, typename>
+    struct __enable_if
+    { };
+  template<typename _Tp>
+    struct __enable_if<true, _Tp>
+    { typedef _Tp __type; };
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct __conditional_type
+    { typedef _Iftrue __type; };
+  template<typename _Iftrue, typename _Iffalse>
+    struct __conditional_type<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse __type; };
+  template<typename _Tp>
+    struct __add_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+    public:
+      typedef typename __if_type::__type __type;
+    };
+  template<>
+    struct __add_unsigned<char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __add_unsigned<signed char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __add_unsigned<short>
+    { typedef unsigned short __type; };
+  template<>
+    struct __add_unsigned<int>
+    { typedef unsigned int __type; };
+  template<>
+    struct __add_unsigned<long>
+    { typedef unsigned long __type; };
+  template<>
+    struct __add_unsigned<long long>
+    { typedef unsigned long long __type; };
+  template<>
+    struct __add_unsigned<bool>;
+  template<>
+    struct __add_unsigned<wchar_t>;
+  template<typename _Tp>
+    struct __remove_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+    public:
+      typedef typename __if_type::__type __type;
+    };
+  template<>
+    struct __remove_unsigned<char>
+    { typedef signed char __type; };
+  template<>
+    struct __remove_unsigned<unsigned char>
+    { typedef signed char __type; };
+  template<>
+    struct __remove_unsigned<unsigned short>
+    { typedef short __type; };
+  template<>
+    struct __remove_unsigned<unsigned int>
+    { typedef int __type; };
+  template<>
+    struct __remove_unsigned<unsigned long>
+    { typedef long __type; };
+  template<>
+    struct __remove_unsigned<unsigned long long>
+    { typedef long long __type; };
+  template<>
+    struct __remove_unsigned<bool>;
+  template<>
+    struct __remove_unsigned<wchar_t>;
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type* __ptr)
+    { return __ptr == 0; }
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type)
+    { return false; }
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { };
+  template<>
+    struct __promote<long double>
+    { typedef long double __type; };
+  template<>
+    struct __promote<double>
+    { typedef double __type; };
+  template<>
+    struct __promote<float>
+    { typedef float __type; };
+  template<typename _Tp, typename _Up,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type>
+    struct __promote_2
+    {
+      typedef __typeof__(_Tp2() + _Up2()) __type;
+    };
+  template<typename _Tp, typename _Up, typename _Vp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type>
+    struct __promote_3
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
+    };
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type,
+           typename _Wp2 = typename __promote<_Wp>::__type>
+    struct __promote_4
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
+    };
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
+      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
+      static const bool __is_signed = ((_Value)(-1) < 0);
+      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
+    };
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 106) * 643L / 2136);
+      static const bool __is_signed = true;
+      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 31);
+      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 308);
+    };
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+    __numeric_traits_integer<_Value>,
+    __numeric_traits_floating<_Value> >::__type
+    { };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    inline _Tp*
+    __addressof(_Tp& __r)
+    {
+      return reinterpret_cast<_Tp*>
+ (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    inline void
+    swap(_Tp& __a, _Tp& __b)
+    {
+      _Tp __tmp = (__a);
+      __a = (__b);
+      __b = (__tmp);
+    }
+  template<typename _Tp, size_t _Nm>
+    inline void
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<class _T1, class _T2>
+    struct pair
+    {
+      typedef _T1 first_type;
+      typedef _T2 second_type;
+      _T1 first;
+      _T2 second;
+      pair()
+      : first(), second() { }
+      pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+      template<class _U1, class _U2>
+ pair(const pair<_U1, _U2>& __p)
+ : first(__p.first), second(__p.second) { }
+    };
+  template<class _T1, class _T2>
+    inline bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+  template<class _T1, class _T2>
+    inline bool
+    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first < __y.first
+      || (!(__y.first < __x.first) && __x.second < __y.second); }
+  template<class _T1, class _T2>
+    inline bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+  template<class _T1, class _T2>
+    inline bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+  template<class _T1, class _T2>
+    inline bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+  template<class _T1, class _T2>
+    inline bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+  template<class _T1, class _T2>
+    inline pair<_T1, _T2>
+    make_pair(_T1 __x, _T2 __y)
+    { return pair<_T1, _T2>(__x, __y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  struct input_iterator_tag { };
+  struct output_iterator_tag { };
+  struct forward_iterator_tag : public input_iterator_tag { };
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+      typedef _Category iterator_category;
+      typedef _Tp value_type;
+      typedef _Distance difference_type;
+      typedef _Pointer pointer;
+      typedef _Reference reference;
+    };
+  template<typename _Iterator>
+    struct iterator_traits
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type value_type;
+      typedef typename _Iterator::difference_type difference_type;
+      typedef typename _Iterator::pointer pointer;
+      typedef typename _Iterator::reference reference;
+    };
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+    };
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+    };
+  template<typename _Iter>
+    inline typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+  template<typename _Iterator, bool _HasBase>
+    struct _Iter_base
+    {
+      typedef _Iterator iterator_type;
+      static iterator_type _S_base(_Iterator __it)
+      { return __it; }
+    };
+  template<typename _Iterator>
+    struct _Iter_base<_Iterator, true>
+    {
+      typedef typename _Iterator::iterator_type iterator_type;
+      static iterator_type _S_base(_Iterator __it)
+      { return __it.base(); }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    __distance(_InputIterator __first, _InputIterator __last,
+               input_iterator_tag)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+  template<typename _RandomAccessIterator>
+    inline typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+      return __last - __first;
+    }
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+      return std::__distance(__first, __last,
+        std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+      while (__n--)
+ ++__i;
+    }
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline void
+    __advance(_BidirectionalIterator& __i, _Distance __n,
+       bidirectional_iterator_tag)
+    {
+      if (__n > 0)
+        while (__n--)
+   ++__i;
+      else
+        while (__n++)
+   --__i;
+    }
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+      __i += __n;
+    }
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+        typename iterator_traits<_Iterator>::value_type,
+        typename iterator_traits<_Iterator>::difference_type,
+        typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator current;
+      typedef iterator_traits<_Iterator> __traits_type;
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::pointer pointer;
+      typedef typename __traits_type::reference reference;
+      reverse_iterator() : current() { }
+      explicit
+      reverse_iterator(iterator_type __x) : current(__x) { }
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+      template<typename _Iter>
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+      iterator_type
+      base() const
+      { return current; }
+      reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+      pointer
+      operator->() const
+      { return &(operator*()); }
+      reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+      reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+      reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+      reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+      reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+      reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+      reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+      reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+  template<typename _Iterator>
+    inline bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _Iterator>
+    inline bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+  template<typename _Iterator>
+    inline bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+  template<typename _Iterator>
+    inline bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+  template<typename _Iterator>
+    inline bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+  template<typename _Iterator>
+    inline bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+  template<typename _Iterator>
+    inline typename reverse_iterator<_Iterator>::difference_type
+    operator-(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() - __x.base(); }
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+       const reverse_iterator<_Iterator>& __x)
+    { return reverse_iterator<_Iterator>(__x.base() - __n); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline typename reverse_iterator<_IteratorL>::difference_type
+    operator-(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() - __x.base(); }
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+    public:
+      typedef _Container container_type;
+      explicit
+      back_insert_iterator(_Container& __x) : container(&__x) { }
+      back_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ container->push_back(__value);
+ return *this;
+      }
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+    public:
+      typedef _Container container_type;
+      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
+      front_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ container->push_front(__value);
+ return *this;
+      }
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+      typename _Container::iterator iter;
+    public:
+      typedef _Container container_type;
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(&__x), iter(__i) {}
+      insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+      }
+      insert_iterator&
+      operator*()
+      { return *this; }
+      insert_iterator&
+      operator++()
+      { return *this; }
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  using std::iterator_traits;
+  using std::iterator;
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+      typedef iterator_traits<_Iterator> __traits_type;
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::reference reference;
+      typedef typename __traits_type::pointer pointer;
+      __normal_iterator() : _M_current(_Iterator()) { }
+      explicit
+      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
+      template<typename _Iter>
+        __normal_iterator(const __normal_iterator<_Iter,
+     typename __enable_if<
+              (std::__are_same<_Iter, typename _Container::pointer>::__value),
+        _Container>::__type>& __i)
+        : _M_current(__i.base()) { }
+      reference
+      operator*() const
+      { return *_M_current; }
+      pointer
+      operator->() const
+      { return _M_current; }
+      __normal_iterator&
+      operator++()
+      {
+ ++_M_current;
+ return *this;
+      }
+      __normal_iterator
+      operator++(int)
+      { return __normal_iterator(_M_current++); }
+      __normal_iterator&
+      operator--()
+      {
+ --_M_current;
+ return *this;
+      }
+      __normal_iterator
+      operator--(int)
+      { return __normal_iterator(_M_current--); }
+      reference
+      operator[](const difference_type& __n) const
+      { return _M_current[__n]; }
+      __normal_iterator&
+      operator+=(const difference_type& __n)
+      { _M_current += __n; return *this; }
+      __normal_iterator
+      operator+(const difference_type& __n) const
+      { return __normal_iterator(_M_current + __n); }
+      __normal_iterator&
+      operator-=(const difference_type& __n)
+      { _M_current -= __n; return *this; }
+      __normal_iterator
+      operator-(const difference_type& __n) const
+      { return __normal_iterator(_M_current - __n); }
+      const _Iterator&
+      base() const
+      { return _M_current; }
+    };
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() == __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() == __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() != __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() != __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() < __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() < __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() > __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() > __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() <= __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() <= __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() >= __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() >= __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() - __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() - __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline __normal_iterator<_Iterator, _Container>
+    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
+       __n, const __normal_iterator<_Iterator, _Container>& __i)
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+}
+namespace std
+{
+  namespace __debug { }
+}
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<bool _BoolType>
+    struct __iter_swap
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          typedef typename iterator_traits<_ForwardIterator1>::value_type
+            _ValueType1;
+          _ValueType1 __tmp = (*__a);
+          *__a = (*__b);
+          *__b = (__tmp);
+ }
+    };
+  template<>
+    struct __iter_swap<true>
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          swap(*__a, *__b);
+        }
+    };
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+      typedef typename iterator_traits<_ForwardIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator2>::value_type
+ _ValueType2;
+      typedef typename iterator_traits<_ForwardIterator1>::reference
+ _ReferenceType1;
+      typedef typename iterator_traits<_ForwardIterator2>::reference
+ _ReferenceType2;
+      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
+ && __are_same<_ValueType1&, _ReferenceType1>::__value
+ && __are_same<_ValueType2&, _ReferenceType2>::__value>::
+ iter_swap(__a, __b);
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+      ;
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+  template<typename _Tp>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+      if (__b < __a)
+ return __b;
+      return __a;
+    }
+  template<typename _Tp>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+      if (__a < __b)
+ return __b;
+      return __a;
+    }
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      if (__comp(__b, __a))
+ return __b;
+      return __a;
+    }
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ return __b;
+      return __a;
+    }
+  template<typename _Iterator>
+    struct _Niter_base
+    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
+    { };
+  template<typename _Iterator>
+    inline typename _Niter_base<_Iterator>::iterator_type
+    __niter_base(_Iterator __it)
+    { return std::_Niter_base<_Iterator>::_S_base(__it); }
+  template<typename _Iterator>
+    struct _Miter_base
+    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
+    { };
+  template<typename _Iterator>
+    inline typename _Miter_base<_Iterator>::iterator_type
+    __miter_base(_Iterator __it)
+    { return std::_Miter_base<_Iterator>::_S_base(__it); }
+  template<bool, bool, typename>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   for (; __first != __last; ++__result, ++__first)
+     *__result = *__first;
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move<false, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = *__first;
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+  template<bool _IsMove>
+    struct __copy_move<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+   return __result + _Num;
+ }
+    };
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
+      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueTypeI)
+                      && __is_pointer<_II>::__value
+                      && __is_pointer<_OI>::__value
+        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
+      return std::__copy_move<_IsMove, __simple,
+                       _Category>::__copy_m(__first, __last, __result);
+    }
+  template<typename _CharT>
+    struct char_traits;
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator;
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator;
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(_CharT*, _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(const _CharT*, const _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
+     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a2(_II __first, _II __last, _OI __result)
+    {
+      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+  template<typename _II, typename _OI>
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+      ;
+      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+  template<bool, bool, typename>
+    struct __copy_move_backward
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   while (__first != __last)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move_backward<false, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+  template<bool _IsMove>
+    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+   return __result - _Num;
+ }
+    };
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
+      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueType1)
+                      && __is_pointer<_BI1>::__value
+                      && __is_pointer<_BI2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+      return std::__copy_move_backward<_IsMove, __simple,
+                                _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      return _BI2(std::__copy_move_backward_a<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      ;
+      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+       const _Tp& __value)
+    {
+      for (; __first != __last; ++__first)
+ *__first = __value;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __first != __last; ++__first)
+ *__first = __tmp;
+    }
+  template<typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
+    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
+         __last - __first);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+      ;
+      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
+      __value);
+    }
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __value;
+      return __first;
+    }
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+  template<typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
+    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
+    {
+      std::__fill_a(__first, __first + __n, __c);
+      return __first + __n;
+    }
+  template<typename _OI, typename _Size, typename _Tp>
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
+    }
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+        static bool
+        equal(_II1 __first1, _II1 __last1, _II2 __first2)
+        {
+   for (; __first1 != __last1; ++__first1, ++__first2)
+     if (!(*__first1 == *__first2))
+       return false;
+   return true;
+ }
+    };
+  template<>
+    struct __equal<true>
+    {
+      template<typename _Tp>
+        static bool
+        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
+        {
+   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
+       * (__last1 - __first1));
+ }
+    };
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = (__is_integer<_ValueType1>::__value
+                      && __is_pointer<_II1>::__value
+                      && __is_pointer<_II2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+        static _II1
+        __newlast1(_II1, _II1 __last1, _II2, _II2)
+        { return __last1; }
+      template<typename _II>
+        static bool
+        __cnd2(_II __first, _II __last)
+        { return __first != __last; }
+    };
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+        static _RAI1
+        __newlast1(_RAI1 __first1, _RAI1 __last1,
+     _RAI2 __first2, _RAI2 __last2)
+        {
+   const typename iterator_traits<_RAI1>::difference_type
+     __diff1 = __last1 - __first1;
+   const typename iterator_traits<_RAI2>::difference_type
+     __diff2 = __last2 - __first2;
+   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+ }
+      template<typename _RAI>
+        static bool
+        __cnd2(_RAI, _RAI)
+        { return true; }
+    };
+  template<bool _BoolType>
+    struct __lexicographical_compare
+    {
+      template<typename _II1, typename _II2>
+        static bool __lc(_II1, _II1, _II2, _II2);
+    };
+  template<bool _BoolType>
+    template<typename _II1, typename _II2>
+      bool
+      __lexicographical_compare<_BoolType>::
+      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+      {
+ typedef typename iterator_traits<_II1>::iterator_category _Category1;
+ typedef typename iterator_traits<_II2>::iterator_category _Category2;
+ typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+ __last1 = __rai_type::__newlast1(__first1, __last1,
+      __first2, __last2);
+ for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+      ++__first1, ++__first2)
+   {
+     if (*__first1 < *__first2)
+       return true;
+     if (*__first2 < *__first1)
+       return false;
+   }
+ return __first1 == __last1 && __first2 != __last2;
+      }
+  template<>
+    struct __lexicographical_compare<true>
+    {
+      template<typename _Tp, typename _Up>
+        static bool
+        __lc(const _Tp* __first1, const _Tp* __last1,
+      const _Up* __first2, const _Up* __last2)
+ {
+   const size_t __len1 = __last1 - __first1;
+   const size_t __len2 = __last2 - __first2;
+   const int __result = __builtin_memcmp(__first1, __first2,
+      std::min(__len1, __len2));
+   return __result != 0 ? __result < 0 : __len1 < __len2;
+ }
+    };
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+      _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+ (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+  && __is_pointer<_II1>::__value
+  && __is_pointer<_II2>::__value);
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+           __first2, __last2);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (*__middle < __val)
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+  template<typename _Size>
+    inline _Size
+    __lg(_Size __n)
+    {
+      _Size __k;
+      for (__k = 0; __n != 0; __n >>= 1)
+ ++__k;
+      return __k - 1;
+    }
+  inline int
+  __lg(int __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+  inline long
+  __lg(long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+  inline long long
+  __lg(long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      ;
+      return std::__equal_aux(std::__niter_base(__first1),
+         std::__niter_base(__last1),
+         std::__niter_base(__first2));
+    }
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+      ;
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return true;
+    }
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      ;
+      ;
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+      std::__niter_base(__last1),
+      std::__niter_base(__first2),
+      std::__niter_base(__last2));
+    }
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+      ;
+      ;
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+    ++__first1, ++__first2)
+ {
+   if (__comp(*__first1, *__first2))
+     return true;
+   if (__comp(*__first2, *__first1))
+     return false;
+ }
+      return __first1 == __last1 && __first2 != __last2;
+    }
+  template<typename _InputIterator1, typename _InputIterator2>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2)
+    {
+      ;
+      while (__first1 != __last1 && *__first1 == *__first2)
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      ;
+      while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+}
+struct _IO_FILE;
+typedef struct _IO_FILE FILE;
+typedef struct _IO_FILE __FILE;
+typedef __builtin_va_list __gnuc_va_list;
+typedef long unsigned int size_t;
+typedef unsigned int wint_t;
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+typedef __mbstate_t mbstate_t;
+extern "C" {
+struct tm;
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   __const wchar_t *__restrict __src) throw ();
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    __const wchar_t *__restrict __src, size_t __n)
+     throw ();
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   __const wchar_t *__restrict __src) throw ();
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    __const wchar_t *__restrict __src, size_t __n)
+     throw ();
+extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
+     throw () __attribute__ ((__pure__));
+extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
+extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
+   size_t __n) throw ();
+typedef struct __locale_struct
+{
+  struct __locale_data *__locales[13];
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+  const char *__names[13];
+} *__locale_t;
+typedef __locale_t locale_t;
+extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
+    __locale_t __loc) throw ();
+extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
+     size_t __n, __locale_t __loc) throw ();
+extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         __const wchar_t *__restrict __s2, size_t __n) throw ();
+extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
+        __locale_t __loc) throw ();
+extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
+    size_t __n, __locale_t __loc) throw ();
+extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, __const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcspbrk (__const wchar_t *__wcs,
+           __const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, __const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcsstr (__const wchar_t *__haystack,
+          __const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   __const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, __const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcswcs (__const wchar_t *__haystack,
+          __const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c,
+           size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern int wmemcmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    __const wchar_t *__restrict __s2, size_t __n) throw ();
+extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
+     throw ();
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     __const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+extern wint_t btowc (int __c) throw ();
+extern int wctob (wint_t __c) throw ();
+extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         __const char *__restrict __s, size_t __n,
+         mbstate_t *__p) throw ();
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (__const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+extern wint_t __btowc_alias (int __c) __asm ("btowc");
+extern __inline __attribute__ ((__gnu_inline__)) wint_t
+__attribute__ ((__leaf__)) btowc (int __c) throw ()
+{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
+   ? (wint_t) __c : __btowc_alias (__c)); }
+extern int __wctob_alias (wint_t __c) __asm ("wctob");
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
+{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
+   ? (int) __wc : __wctob_alias (__wc)); }
+extern __inline __attribute__ ((__gnu_inline__)) size_t
+__attribute__ ((__leaf__)) mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
+{ return (__ps != __null
+   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    __const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+extern size_t wcsrtombs (char *__restrict __dst,
+    __const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     __const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) throw ();
+extern size_t wcsnrtombs (char *__restrict __dst,
+     __const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) throw ();
+extern int wcwidth (wchar_t __c) throw ();
+extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();
+extern double wcstod (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) throw ();
+extern float wcstof (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long double wcstold (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long int wcstol (__const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) throw ();
+extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern long long int wcstoll (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) throw ();
+__extension__
+extern long long int wcstoq (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) throw ();
+extern long int wcstol_l (__const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     __locale_t __loc) throw ();
+extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, __locale_t __loc) throw ();
+__extension__
+extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, __locale_t __loc) throw ();
+__extension__
+extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw ();
+extern double wcstod_l (__const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+extern float wcstof_l (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+extern long double wcstold_l (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         __locale_t __loc) throw ();
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   __const wchar_t *__restrict __src) throw ();
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    __const wchar_t *__restrict __src, size_t __n)
+     throw ();
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+extern int fwide (__FILE *__fp, int __mode) throw ();
+extern int fwprintf (__FILE *__restrict __stream,
+       __const wchar_t *__restrict __format, ...)
+                                                           ;
+extern int wprintf (__const wchar_t *__restrict __format, ...)
+                                                           ;
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       __const wchar_t *__restrict __format, ...)
+     throw () ;
+extern int vfwprintf (__FILE *__restrict __s,
+        __const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+extern int vwprintf (__const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        __const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+extern int fwscanf (__FILE *__restrict __stream,
+      __const wchar_t *__restrict __format, ...)
+                                                          ;
+extern int wscanf (__const wchar_t *__restrict __format, ...)
+                                                          ;
+extern int swscanf (__const wchar_t *__restrict __s,
+      __const wchar_t *__restrict __format, ...)
+     throw () ;
+extern int vfwscanf (__FILE *__restrict __s,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+extern int vwscanf (__const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+extern int vswscanf (__const wchar_t *__restrict __s,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+extern wint_t getwchar (void);
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar (wchar_t __wc);
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+extern int fputws (__const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+extern int fputws_unlocked (__const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   __const wchar_t *__restrict __format,
+   __const struct tm *__restrict __tp) throw ();
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     __const wchar_t *__restrict __format,
+     __const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
+          __const wchar_t *__restrict __s2, size_t __n,
+          size_t __ns1) throw ();
+extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")
+            ;
+extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")
+     __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemcpy_chk (__s1, __s2, __n,
+         __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmemcpy_chk_warn (__s1, __s2, __n,
+       __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmemcpy_alias (__s1, __s2, __n);
+}
+extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
+    size_t __n, size_t __ns1) throw ();
+extern wchar_t *__wmemmove_alias (wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")
+                               ;
+extern wchar_t *__wmemmove_chk_warn (wchar_t *__s1, __const wchar_t *__s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")
+     __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw ()
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemmove_chk (__s1, __s2, __n,
+          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmemmove_chk_warn (__s1, __s2, __n,
+        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmemmove_alias (__s1, __s2, __n);
+}
+extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
+    __const wchar_t *__restrict __s2, size_t __n,
+    size_t __ns1) throw ();
+extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")
+                           ;
+extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")
+     __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmempcpy_chk (__s1, __s2, __n,
+          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmempcpy_chk_warn (__s1, __s2, __n,
+        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmempcpy_alias (__s1, __s2, __n);
+}
+extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
+          size_t __ns) throw ();
+extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
+                             ;
+extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")
+     __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ()
+{
+  if (__builtin_object_size (__s, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemset_chk (__s, __c, __n, __builtin_object_size (__s, 0) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__s, 0) / sizeof (wchar_t))
+ return __wmemset_chk_warn (__s, __c, __n,
+       __builtin_object_size (__s, 0) / sizeof (wchar_t));
+    }
+  return __wmemset_alias (__s, __c, __n);
+}
+extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
+         __const wchar_t *__restrict __src,
+         size_t __n) throw ();
+extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")
+                                                ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcscpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcscpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcscpy_alias (__dest, __src);
+}
+extern wchar_t *__wcpcpy_chk (wchar_t *__restrict __dest,
+         __const wchar_t *__restrict __src,
+         size_t __destlen) throw ();
+extern wchar_t *__wcpcpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcpcpy")
+                                                ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcpcpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcpcpy_alias (__dest, __src);
+}
+extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src, size_t __n,
+          size_t __destlen) throw ();
+extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")
+                          ;
+extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")
+     __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcsncpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wcsncpy_chk (__dest, __src, __n,
+         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
+ return __wcsncpy_chk_warn (__dest, __src, __n,
+       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+    }
+  return __wcsncpy_alias (__dest, __src, __n);
+}
+extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src, size_t __n,
+          size_t __destlen) throw ();
+extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")
+                          ;
+extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")
+     __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcpncpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wcpncpy_chk (__dest, __src, __n,
+         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
+ return __wcpncpy_chk_warn (__dest, __src, __n,
+       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+    }
+  return __wcpncpy_alias (__dest, __src, __n);
+}
+extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
+         __const wchar_t *__restrict __src,
+         size_t __destlen) throw ();
+extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")
+                                                ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcscat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcscat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcscat_alias (__dest, __src);
+}
+extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src,
+          size_t __n, size_t __destlen) throw ();
+extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")
+                          ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+__attribute__ ((__leaf__)) wcsncat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcsncat_chk (__dest, __src, __n,
+     __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcsncat_alias (__dest, __src, __n);
+}
+extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
+      int __flag, size_t __s_len,
+      __const wchar_t *__restrict __format, ...)
+     throw () ;
+extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")
+             ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) swprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw ()
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
+    return __swprintf_chk (__s, __n, 2 - 1,
+      __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+      __fmt, __builtin_va_arg_pack ());
+  return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ());
+}
+extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
+       int __flag, size_t __s_len,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")
+                                     ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) vswprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
+    return __vswprintf_chk (__s, __n, 2 - 1,
+       __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t), __fmt, __ap);
+  return __vswprintf_alias (__s, __n, __fmt, __ap);
+}
+extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
+      __const wchar_t *__restrict __format, ...);
+extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
+     ...);
+extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __ap);
+extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
+      __gnuc_va_list __ap);
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+wprintf (__const wchar_t *__restrict __fmt, ...)
+{
+  return __wprintf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
+{
+  return __fwprintf_chk (__stream, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vwprintf_chk (2 - 1, __fmt, __ap);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vfwprintf (__FILE *__restrict __stream,
+    __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vfwprintf_chk (__stream, 2 - 1, __fmt, __ap);
+}
+extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
+         __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")
+                                              __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
+fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgetws_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+        __n, __stream);
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
+ return __fgetws_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+      __n, __stream);
+    }
+  return __fgetws_alias (__s, __n, __stream);
+}
+extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
+           int __n, __FILE *__restrict __stream)
+  __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")
+  __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
+fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgetws_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+          __n, __stream);
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
+ return __fgetws_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+        __n, __stream);
+    }
+  return __fgetws_unlocked_alias (__s, __n, __stream);
+}
+extern size_t __wcrtomb_chk (char *__restrict __s, wchar_t __wchar,
+        mbstate_t *__restrict __p,
+        size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
+extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")
+                                                __attribute__ ((__warn_unused_result__));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+__attribute__ ((__leaf__)) wcrtomb (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw ()
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
+    return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, 2 > 1));
+  return __wcrtomb_alias (__s, __wchar, __ps);
+}
+extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
+          __const char **__restrict __src,
+          size_t __len, mbstate_t *__restrict __ps,
+          size_t __dstlen) throw ();
+extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")
+                   ;
+extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")
+     __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbsrtowcs_chk (__dst, __src, __len, __ps,
+    __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
+         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
+}
+extern size_t __wcsrtombs_chk (char *__restrict __dst,
+          __const wchar_t **__restrict __src,
+          size_t __len, mbstate_t *__restrict __ps,
+          size_t __dstlen) throw ();
+extern size_t __wcsrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")
+                   ;
+extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")
+    __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcsrtombs_alias (__dst, __src, __len, __ps);
+}
+extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
+    __const char **__restrict __src, size_t __nmc,
+    size_t __len, mbstate_t *__restrict __ps,
+    size_t __dstlen) throw ();
+extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")
+                    ;
+extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")
+     __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
+     __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
+          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
+}
+extern size_t __wcsnrtombs_chk (char *__restrict __dst,
+    __const wchar_t **__restrict __src,
+    size_t __nwc, size_t __len,
+    mbstate_t *__restrict __ps, size_t __dstlen)
+     throw ();
+extern size_t __wcsnrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")
+                                                  ;
+extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")
+     __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
+     __builtin_object_size (__dst, 2 > 1));
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
+          __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
+}
+}
+namespace std
+{
+  using ::mbstate_t;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  using ::wint_t;
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+  using ::swprintf;
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+  using ::vfwscanf;
+  using ::vswprintf;
+  using ::vswscanf;
+  using ::vwprintf;
+  using ::vwscanf;
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+  using ::wcstof;
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+}
+namespace __gnu_cxx
+{
+  using ::wcstold;
+  using ::wcstoll;
+  using ::wcstoull;
+}
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  typedef long streamoff;
+  typedef ptrdiff_t streamsize;
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+    public:
+      fpos()
+      : _M_off(0), _M_state() { }
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+      operator streamoff() const { return _M_off; }
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+      _StateT
+      state() const
+      { return _M_state; }
+      fpos&
+      operator+=(streamoff __off)
+      {
+ _M_off += __off;
+ return *this;
+      }
+      fpos&
+      operator-=(streamoff __off)
+      {
+ _M_off -= __off;
+ return *this;
+      }
+      fpos
+      operator+(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos += __off;
+ return __pos;
+      }
+      fpos
+      operator-(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos -= __off;
+ return __pos;
+      }
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+  typedef fpos<mbstate_t> streampos;
+  typedef fpos<mbstate_t> wstreampos;
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+      static int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+      static std::size_t
+      length(const char_type* __s);
+      static const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+      static char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+      static int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+      static int_type
+      eof()
+      { return static_cast<int_type>(-1); }
+      static int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+  template<typename _CharT>
+    int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+ if (lt(__s1[__i], __s2[__i]))
+   return -1;
+ else if (lt(__s2[__i], __s1[__i]))
+   return 1;
+      return 0;
+    }
+  template<typename _CharT>
+    std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+  template<typename _CharT>
+    const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+          __n * sizeof(char_type)));
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return __builtin_memcmp(__s1, __s2, __n); }
+      static size_t
+      length(const char_type* __s)
+      { return __builtin_strlen(__s); }
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
+      static char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+      static int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+      static int_type
+      eof()
+      { return static_cast<int_type>(-1); }
+      static int_type
+      not_eof(const int_type& __c)
+      { return (__c == eof()) ? 0 : __c; }
+  };
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t char_type;
+      typedef wint_t int_type;
+      typedef streamoff off_type;
+      typedef wstreampos pos_type;
+      typedef mbstate_t state_type;
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcmp(__s1, __s2, __n); }
+      static size_t
+      length(const char_type* __s)
+      { return wcslen(__s); }
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return wmemchr(__s, __a, __n); }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemmove(__s1, __s2, __n); }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcpy(__s1, __s2, __n); }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return wmemset(__s, __a, __n); }
+      static char_type
+      to_char_type(const int_type& __c)
+      { return char_type(__c); }
+      static int_type
+      to_int_type(const char_type& __c)
+      { return int_type(__c); }
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+      static int_type
+      eof()
+      { return static_cast<int_type>((0xffffffffu)); }
+      static int_type
+      not_eof(const int_type& __c)
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+}
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  class exception
+  {
+  public:
+    exception() throw() { }
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
+  };
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() throw() { }
+    virtual ~bad_exception() throw();
+    virtual const char* what() const throw();
+  };
+  typedef void (*terminate_handler) ();
+  typedef void (*unexpected_handler) ();
+  terminate_handler set_terminate(terminate_handler) throw();
+  void terminate() throw() __attribute__ ((__noreturn__));
+  unexpected_handler set_unexpected(unexpected_handler) throw();
+  void unexpected() __attribute__ ((__noreturn__));
+  bool uncaught_exception() throw() __attribute__ ((__pure__));
+}
+namespace __gnu_cxx
+{
+  void __verbose_terminate_handler();
+}
+}
+#pragma GCC visibility pop
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
+  };
+  struct nothrow_t { };
+  extern const nothrow_t nothrow;
+  typedef void (*new_handler)();
+  new_handler set_new_handler(new_handler) throw();
+}
+void* operator new(std::size_t) throw (std::bad_alloc);
+void* operator new[](std::size_t) throw (std::bad_alloc);
+void operator delete(void*) throw();
+void operator delete[](void*) throw();
+void* operator new(std::size_t, const std::nothrow_t&) throw();
+void* operator new[](std::size_t, const std::nothrow_t&) throw();
+void operator delete(void*, const std::nothrow_t&) throw();
+void operator delete[](void*, const std::nothrow_t&) throw();
+inline void* operator new(std::size_t, void* __p) throw() { return __p; }
+inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
+inline void operator delete (void*, void*) throw() { }
+inline void operator delete[](void*, void*) throw() { }
+}
+#pragma GCC visibility pop
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  using std::size_t;
+  using std::ptrdiff_t;
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+      template<typename _Tp1>
+        struct rebind
+        { typedef new_allocator<_Tp1> other; };
+      new_allocator() throw() { }
+      new_allocator(const new_allocator&) throw() { }
+      template<typename _Tp1>
+        new_allocator(const new_allocator<_Tp1>&) throw() { }
+      ~new_allocator() throw() { }
+      pointer
+      address(reference __x) const { return std::__addressof(__x); }
+      const_pointer
+      address(const_reference __x) const { return std::__addressof(__x); }
+      pointer
+      allocate(size_type __n, const void* = 0)
+      {
+ if (__n > this->max_size())
+   std::__throw_bad_alloc();
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+      void
+      deallocate(pointer __p, size_type)
+      { ::operator delete(__p); }
+      size_type
+      max_size() const throw()
+      { return size_t(-1) / sizeof(_Tp); }
+      void
+      construct(pointer __p, const _Tp& __val)
+      { ::new((void *)__p) _Tp(__val); }
+      void
+      destroy(pointer __p) { __p->~_Tp(); }
+    };
+  template<typename _Tp>
+    inline bool
+    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return true; }
+  template<typename _Tp>
+    inline bool
+    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return false; }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    class allocator;
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef void* pointer;
+      typedef const void* const_pointer;
+      typedef void value_type;
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+    };
+  template<typename _Tp>
+    class allocator: public __gnu_cxx::new_allocator<_Tp>
+    {
+   public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+      allocator() throw() { }
+      allocator(const allocator& __a) throw()
+      : __gnu_cxx::new_allocator<_Tp>(__a) { }
+      template<typename _Tp1>
+        allocator(const allocator<_Tp1>&) throw() { }
+      ~allocator() throw() { }
+    };
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    { return true; }
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return true; }
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    { return false; }
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return false; }
+  extern template class allocator<char>;
+  extern template class allocator<wchar_t>;
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_swap
+    { static void _S_do_it(_Alloc&, _Alloc&) { } };
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two)
+      {
+ if (__one != __two)
+   swap(__one, __two);
+      }
+    };
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_neq
+    {
+      static bool
+      _S_do_it(const _Alloc&, const _Alloc&)
+      { return false; }
+    };
+  template<typename _Alloc>
+    struct __alloc_neq<_Alloc, false>
+    {
+      static bool
+      _S_do_it(const _Alloc& __one, const _Alloc& __two)
+      { return __one != __two; }
+    };
+}
+enum
+{
+  __LC_CTYPE = 0,
+  __LC_NUMERIC = 1,
+  __LC_TIME = 2,
+  __LC_COLLATE = 3,
+  __LC_MONETARY = 4,
+  __LC_MESSAGES = 5,
+  __LC_ALL = 6,
+  __LC_PAPER = 7,
+  __LC_NAME = 8,
+  __LC_ADDRESS = 9,
+  __LC_TELEPHONE = 10,
+  __LC_MEASUREMENT = 11,
+  __LC_IDENTIFICATION = 12
+};
+extern "C" {
+struct lconv
+{
+  char *decimal_point;
+  char *thousands_sep;
+  char *grouping;
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+  char p_cs_precedes;
+  char p_sep_by_space;
+  char n_cs_precedes;
+  char n_sep_by_space;
+  char p_sign_posn;
+  char n_sign_posn;
+  char int_p_cs_precedes;
+  char int_p_sep_by_space;
+  char int_n_cs_precedes;
+  char int_n_sep_by_space;
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+};
+extern char *setlocale (int __category, __const char *__locale) throw ();
+extern struct lconv *localeconv (void) throw ();
+extern __locale_t newlocale (int __category_mask, __const char *__locale,
+        __locale_t __base) throw ();
+extern __locale_t duplocale (__locale_t __dataset) throw ();
+extern void freelocale (__locale_t __dataset) throw ();
+extern __locale_t uselocale (__locale_t __dataset) throw ();
+}
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  extern "C" __typeof(uselocale) __uselocale;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  typedef __locale_t __c_locale;
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+    __builtin_va_end(__args);
+    __gnu_cxx::__uselocale(__old);
+    return __ret;
+  }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class ios_base;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+  typedef basic_ios<char> ios;
+  typedef basic_streambuf<char> streambuf;
+  typedef basic_istream<char> istream;
+  typedef basic_ostream<char> ostream;
+  typedef basic_iostream<char> iostream;
+  typedef basic_stringbuf<char> stringbuf;
+  typedef basic_istringstream<char> istringstream;
+  typedef basic_ostringstream<char> ostringstream;
+  typedef basic_stringstream<char> stringstream;
+  typedef basic_filebuf<char> filebuf;
+  typedef basic_ifstream<char> ifstream;
+  typedef basic_ofstream<char> ofstream;
+  typedef basic_fstream<char> fstream;
+  typedef basic_ios<wchar_t> wios;
+  typedef basic_streambuf<wchar_t> wstreambuf;
+  typedef basic_istream<wchar_t> wistream;
+  typedef basic_ostream<wchar_t> wostream;
+  typedef basic_iostream<wchar_t> wiostream;
+  typedef basic_stringbuf<wchar_t> wstringbuf;
+  typedef basic_istringstream<wchar_t> wistringstream;
+  typedef basic_ostringstream<wchar_t> wostringstream;
+  typedef basic_stringstream<wchar_t> wstringstream;
+  typedef basic_filebuf<wchar_t> wfilebuf;
+  typedef basic_ifstream<wchar_t> wifstream;
+  typedef basic_ofstream<wchar_t> wofstream;
+  typedef basic_fstream<wchar_t> wfstream;
+}
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef int __daddr_t;
+typedef long int __swblk_t;
+typedef int __key_t;
+typedef int __clockid_t;
+typedef void * __timer_t;
+typedef long int __blksize_t;
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+typedef long int __ssize_t;
+typedef __off64_t __loff_t;
+typedef __quad_t *__qaddr_t;
+typedef char *__caddr_t;
+typedef long int __intptr_t;
+typedef unsigned int __socklen_t;
+extern "C" {
+enum
+{
+  _ISupper = (1 << (0)),
+  _ISlower = (1 << (1)),
+  _ISalpha = (1 << (2)),
+  _ISdigit = (1 << (3)),
+  _ISxdigit = (1 << (4)),
+  _ISspace = (1 << (5)),
+  _ISprint = (1 << (6)),
+  _ISgraph = (1 << (7)),
+  _ISblank = (1 << (8)),
+  _IScntrl = (1 << (9)),
+  _ISpunct = (1 << (10)),
+  _ISalnum = (1 << (11))
+};
+extern __const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const));
+extern __const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const));
+extern __const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const));
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+extern int tolower (int __c) throw ();
+extern int toupper (int __c) throw ();
+extern int isblank (int) throw ();
+extern int isctype (int __c, int __mask) throw ();
+extern int isascii (int __c) throw ();
+extern int toascii (int __c) throw ();
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+extern int isalnum_l (int, __locale_t) throw ();
+extern int isalpha_l (int, __locale_t) throw ();
+extern int iscntrl_l (int, __locale_t) throw ();
+extern int isdigit_l (int, __locale_t) throw ();
+extern int islower_l (int, __locale_t) throw ();
+extern int isgraph_l (int, __locale_t) throw ();
+extern int isprint_l (int, __locale_t) throw ();
+extern int ispunct_l (int, __locale_t) throw ();
+extern int isspace_l (int, __locale_t) throw ();
+extern int isupper_l (int, __locale_t) throw ();
+extern int isxdigit_l (int, __locale_t) throw ();
+extern int isblank_l (int, __locale_t) throw ();
+extern int __tolower_l (int __c, __locale_t __l) throw ();
+extern int tolower_l (int __c, __locale_t __l) throw ();
+extern int __toupper_l (int __c, __locale_t __l) throw ();
+extern int toupper_l (int __c, __locale_t __l) throw ();
+}
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class locale;
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+  template<> class ctype<wchar_t>;
+  template<typename _CharT>
+    class ctype_byname;
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+}
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT> class
+    collate_byname;
+  class time_base;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+  class money_base;
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+}
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+  class messages_base;
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+}
+#pragma GCC visibility push(default)
+namespace __cxxabiv1
+{
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+    virtual void __pure_dummy() = 0;
+  };
+}
+#pragma GCC visibility pop
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+      typedef _Arg argument_type;
+      typedef _Result result_type;
+    };
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+      typedef _Arg1 first_argument_type;
+      typedef _Arg2 second_argument_type;
+      typedef _Result result_type;
+    };
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+    };
+  template<typename _Tp>
+    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+    public:
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+  template<typename _Predicate>
+    inline unary_negate<_Predicate>
+    not1(const _Predicate& __pred)
+    { return unary_negate<_Predicate>(__pred); }
+  template<typename _Predicate>
+    class binary_negate
+    : public binary_function<typename _Predicate::first_argument_type,
+        typename _Predicate::second_argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+    public:
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+      bool
+      operator()(const typename _Predicate::first_argument_type& __x,
+   const typename _Predicate::second_argument_type& __y) const
+      { return !_M_pred(__x, __y); }
+    };
+  template<typename _Predicate>
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg);
+    public:
+      pointer_to_unary_function() { }
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+    public:
+      pointer_to_binary_function() { }
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+  template<typename _Tp>
+    struct _Identity : public unary_function<_Tp,_Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+  template<typename _Pair>
+    struct _Select1st : public unary_function<_Pair,
+           typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+    };
+  template<typename _Pair>
+    struct _Select2nd : public unary_function<_Pair,
+           typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+    public:
+      binder1st(const _Operation& __x,
+  const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } ;
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+    public:
+      binder2nd(const _Operation& __x,
+  const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } ;
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    }
+}
+#pragma GCC visibility push(default)
+typedef __time_t time_t;
+struct timespec
+  {
+    __time_t tv_sec;
+    long int tv_nsec;
+  };
+typedef __pid_t pid_t;
+struct sched_param
+  {
+    int __sched_priority;
+  };
+extern "C" {
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+extern int unshare (int __flags) throw ();
+extern int sched_getcpu (void) throw ();
+extern int setns (int __fd, int __nstype) throw ();
+}
+struct __sched_param
+  {
+    int __sched_priority;
+  };
+typedef unsigned long int __cpu_mask;
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+extern "C" {
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+  throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () __attribute__ ((__warn_unused_result__));
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+}
+extern "C" {
+extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param)
+     throw ();
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          __const struct sched_param *__param) throw ();
+extern int sched_getscheduler (__pid_t __pid) throw ();
+extern int sched_yield (void) throw ();
+extern int sched_get_priority_max (int __algorithm) throw ();
+extern int sched_get_priority_min (int __algorithm) throw ();
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         __const cpu_set_t *__cpuset) throw ();
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+}
+extern "C" {
+struct timeval
+  {
+    __time_t tv_sec;
+    __suseconds_t tv_usec;
+  };
+struct timex
+{
+  unsigned int modes;
+  long int offset;
+  long int freq;
+  long int maxerror;
+  long int esterror;
+  int status;
+  long int constant;
+  long int precision;
+  long int tolerance;
+  struct timeval time;
+  long int tick;
+  long int ppsfreq;
+  long int jitter;
+  int shift;
+  long int stabil;
+  long int jitcnt;
+  long int calcnt;
+  long int errcnt;
+  long int stbcnt;
+  int tai;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32;
+};
+extern "C" {
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
+}
+typedef __clock_t clock_t;
+typedef __clockid_t clockid_t;
+typedef __timer_t timer_t;
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+  long int tm_gmtoff;
+  __const char *tm_zone;
+};
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+struct sigevent;
+extern clock_t clock (void) throw ();
+extern time_t time (time_t *__timer) throw ();
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+extern time_t mktime (struct tm *__tp) throw ();
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   __const char *__restrict __format,
+   __const struct tm *__restrict __tp) throw ();
+extern char *strptime (__const char *__restrict __s,
+         __const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     __const char *__restrict __format,
+     __const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+extern char *strptime_l (__const char *__restrict __s,
+    __const char *__restrict __fmt, struct tm *__tp,
+    __locale_t __loc) throw ();
+extern struct tm *gmtime (__const time_t *__timer) throw ();
+extern struct tm *localtime (__const time_t *__timer) throw ();
+extern struct tm *gmtime_r (__const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+extern struct tm *localtime_r (__const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+extern char *asctime (__const struct tm *__tp) throw ();
+extern char *ctime (__const time_t *__timer) throw ();
+extern char *asctime_r (__const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+extern char *ctime_r (__const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+extern char *tzname[2];
+extern void tzset (void) throw ();
+extern int daylight;
+extern long int timezone;
+extern int stime (__const time_t *__when) throw ();
+extern time_t timegm (struct tm *__tp) throw ();
+extern time_t timelocal (struct tm *__tp) throw ();
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+extern int nanosleep (__const struct timespec *__requested_time,
+        struct timespec *__remaining);
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
+     throw ();
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       __const struct timespec *__req,
+       struct timespec *__rem);
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+extern int timer_delete (timer_t __timerid) throw ();
+extern int timer_settime (timer_t __timerid, int __flags,
+     __const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+extern int timer_getoverrun (timer_t __timerid) throw ();
+extern int getdate_err;
+extern struct tm *getdate (__const char *__string);
+extern int getdate_r (__const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+}
+typedef unsigned long int pthread_t;
+typedef union
+{
+  char __size[56];
+  long int __align;
+} pthread_attr_t;
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+typedef union
+{
+  struct __pthread_mutex_s
+  {
+    int __lock;
+    unsigned int __count;
+    int __owner;
+    unsigned int __nusers;
+    int __kind;
+    int __spins;
+    __pthread_list_t __list;
+  } __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+typedef union
+{
+  struct
+  {
+    int __lock;
+    unsigned int __futex;
+    __extension__ unsigned long long int __total_seq;
+    __extension__ unsigned long long int __wakeup_seq;
+    __extension__ unsigned long long int __woken_seq;
+    void *__mutex;
+    unsigned int __nwaiters;
+    unsigned int __broadcast_seq;
+  } __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+typedef unsigned int pthread_key_t;
+typedef int pthread_once_t;
+typedef union
+{
+  struct
+  {
+    int __lock;
+    unsigned int __nr_readers;
+    unsigned int __readers_wakeup;
+    unsigned int __writer_wakeup;
+    unsigned int __nr_readers_queued;
+    unsigned int __nr_writers_queued;
+    int __writer;
+    int __shared;
+    unsigned long int __pad1;
+    unsigned long int __pad2;
+    unsigned int __flags;
+  } __data;
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+typedef volatile int pthread_spinlock_t;
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+typedef long int __jmp_buf[64] __attribute__ ((__aligned__ (16)));
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+  PTHREAD_CREATE_DETACHED
+};
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+};
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+  PTHREAD_EXPLICIT_SCHED
+};
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+  PTHREAD_SCOPE_PROCESS
+};
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+  PTHREAD_PROCESS_SHARED
+};
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+  PTHREAD_CANCEL_DISABLE
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+  PTHREAD_CANCEL_ASYNCHRONOUS
+};
+extern "C" {
+extern int pthread_create (pthread_t *__restrict __newthread,
+      __const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+extern int pthread_join (pthread_t __th, void **__thread_return);
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     __const struct timespec *__abstime);
+extern int pthread_detach (pthread_t __th) throw ();
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
+           __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           __const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     __const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_attr_getaffinity_np (__const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      __const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_setname_np (pthread_t __target_thread, __const char *__name)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_getconcurrency (void) throw ();
+extern int pthread_setconcurrency (int __level) throw ();
+extern int pthread_yield (void) throw ();
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       __const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+extern int pthread_cancel (pthread_t __th);
+extern void pthread_testcancel (void);
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          __const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        __const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_getprioceiling (__const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getprotocol (__const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getprioceiling (__const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getrobust (__const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_getrobust_np (__const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    __const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           __const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           __const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         __const pthread_condattr_t *__restrict
+         __cond_attr) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       __const struct timespec *__restrict
+       __abstime) __attribute__ ((__nonnull__ (1, 2, 3)));
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_getpshared (__const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_getclock (__const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     __const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+extern int pthread_setspecific (pthread_key_t __key,
+    __const void *__pointer) throw () ;
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) throw ();
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
+{
+  return __thread1 == __thread2;
+}
+}
+extern "C" {
+typedef __ssize_t ssize_t;
+typedef __gid_t gid_t;
+typedef __uid_t uid_t;
+typedef __off_t off_t;
+typedef __off64_t off64_t;
+typedef __useconds_t useconds_t;
+typedef __intptr_t intptr_t;
+typedef __socklen_t socklen_t;
+extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
+extern int euidaccess (__const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int eaccess (__const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int faccessat (int __fd, __const char *__file, int __type, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
+extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
+     throw ();
+extern int close (int __fd);
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));
+extern ssize_t write (int __fd, __const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
+        __off_t __offset) __attribute__ ((__warn_unused_result__));
+extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
+         __off_t __offset) __attribute__ ((__warn_unused_result__));
+extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
+   __off64_t __offset) __attribute__ ((__warn_unused_result__));
+extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
+    __off64_t __offset) __attribute__ ((__warn_unused_result__));
+extern int pipe (int __pipedes[2]) throw () __attribute__ ((__warn_unused_result__));
+extern int pipe2 (int __pipedes[2], int __flags) throw () __attribute__ ((__warn_unused_result__));
+extern unsigned int alarm (unsigned int __seconds) throw ();
+extern unsigned int sleep (unsigned int __seconds);
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     throw ();
+extern int usleep (__useconds_t __useconds);
+extern int pause (void);
+extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () __attribute__ ((__warn_unused_result__));
+extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int fchownat (int __fd, __const char *__file, __uid_t __owner,
+       __gid_t __group, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int fchdir (int __fd) throw () __attribute__ ((__warn_unused_result__));
+extern char *getcwd (char *__buf, size_t __size) throw () __attribute__ ((__warn_unused_result__));
+extern char *get_current_dir_name (void) throw ();
+extern char *getwd (char *__buf)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
+extern int dup (int __fd) throw () __attribute__ ((__warn_unused_result__));
+extern int dup2 (int __fd, int __fd2) throw ();
+extern int dup3 (int __fd, int __fd2, int __flags) throw ();
+extern char **__environ;
+extern char **environ;
+extern int execve (__const char *__path, char *__const __argv[],
+     char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int execv (__const char *__path, char *__const __argv[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int execle (__const char *__path, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int execl (__const char *__path, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int execvp (__const char *__file, char *__const __argv[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int execlp (__const char *__file, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int execvpe (__const char *__file, char *__const __argv[],
+      char *__const __envp[])
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nice (int __inc) throw () __attribute__ ((__warn_unused_result__));
+extern void _exit (int __status) __attribute__ ((__noreturn__));
+enum
+  {
+    _PC_LINK_MAX,
+    _PC_MAX_CANON,
+    _PC_MAX_INPUT,
+    _PC_NAME_MAX,
+    _PC_PATH_MAX,
+    _PC_PIPE_BUF,
+    _PC_CHOWN_RESTRICTED,
+    _PC_NO_TRUNC,
+    _PC_VDISABLE,
+    _PC_SYNC_IO,
+    _PC_ASYNC_IO,
+    _PC_PRIO_IO,
+    _PC_SOCK_MAXBUF,
+    _PC_FILESIZEBITS,
+    _PC_REC_INCR_XFER_SIZE,
+    _PC_REC_MAX_XFER_SIZE,
+    _PC_REC_MIN_XFER_SIZE,
+    _PC_REC_XFER_ALIGN,
+    _PC_ALLOC_SIZE_MIN,
+    _PC_SYMLINK_MAX,
+    _PC_2_SYMLINKS
+  };
+enum
+  {
+    _SC_ARG_MAX,
+    _SC_CHILD_MAX,
+    _SC_CLK_TCK,
+    _SC_NGROUPS_MAX,
+    _SC_OPEN_MAX,
+    _SC_STREAM_MAX,
+    _SC_TZNAME_MAX,
+    _SC_JOB_CONTROL,
+    _SC_SAVED_IDS,
+    _SC_REALTIME_SIGNALS,
+    _SC_PRIORITY_SCHEDULING,
+    _SC_TIMERS,
+    _SC_ASYNCHRONOUS_IO,
+    _SC_PRIORITIZED_IO,
+    _SC_SYNCHRONIZED_IO,
+    _SC_FSYNC,
+    _SC_MAPPED_FILES,
+    _SC_MEMLOCK,
+    _SC_MEMLOCK_RANGE,
+    _SC_MEMORY_PROTECTION,
+    _SC_MESSAGE_PASSING,
+    _SC_SEMAPHORES,
+    _SC_SHARED_MEMORY_OBJECTS,
+    _SC_AIO_LISTIO_MAX,
+    _SC_AIO_MAX,
+    _SC_AIO_PRIO_DELTA_MAX,
+    _SC_DELAYTIMER_MAX,
+    _SC_MQ_OPEN_MAX,
+    _SC_MQ_PRIO_MAX,
+    _SC_VERSION,
+    _SC_PAGESIZE,
+    _SC_RTSIG_MAX,
+    _SC_SEM_NSEMS_MAX,
+    _SC_SEM_VALUE_MAX,
+    _SC_SIGQUEUE_MAX,
+    _SC_TIMER_MAX,
+    _SC_BC_BASE_MAX,
+    _SC_BC_DIM_MAX,
+    _SC_BC_SCALE_MAX,
+    _SC_BC_STRING_MAX,
+    _SC_COLL_WEIGHTS_MAX,
+    _SC_EQUIV_CLASS_MAX,
+    _SC_EXPR_NEST_MAX,
+    _SC_LINE_MAX,
+    _SC_RE_DUP_MAX,
+    _SC_CHARCLASS_NAME_MAX,
+    _SC_2_VERSION,
+    _SC_2_C_BIND,
+    _SC_2_C_DEV,
+    _SC_2_FORT_DEV,
+    _SC_2_FORT_RUN,
+    _SC_2_SW_DEV,
+    _SC_2_LOCALEDEF,
+    _SC_PII,
+    _SC_PII_XTI,
+    _SC_PII_SOCKET,
+    _SC_PII_INTERNET,
+    _SC_PII_OSI,
+    _SC_POLL,
+    _SC_SELECT,
+    _SC_UIO_MAXIOV,
+    _SC_IOV_MAX = _SC_UIO_MAXIOV,
+    _SC_PII_INTERNET_STREAM,
+    _SC_PII_INTERNET_DGRAM,
+    _SC_PII_OSI_COTS,
+    _SC_PII_OSI_CLTS,
+    _SC_PII_OSI_M,
+    _SC_T_IOV_MAX,
+    _SC_THREADS,
+    _SC_THREAD_SAFE_FUNCTIONS,
+    _SC_GETGR_R_SIZE_MAX,
+    _SC_GETPW_R_SIZE_MAX,
+    _SC_LOGIN_NAME_MAX,
+    _SC_TTY_NAME_MAX,
+    _SC_THREAD_DESTRUCTOR_ITERATIONS,
+    _SC_THREAD_KEYS_MAX,
+    _SC_THREAD_STACK_MIN,
+    _SC_THREAD_THREADS_MAX,
+    _SC_THREAD_ATTR_STACKADDR,
+    _SC_THREAD_ATTR_STACKSIZE,
+    _SC_THREAD_PRIORITY_SCHEDULING,
+    _SC_THREAD_PRIO_INHERIT,
+    _SC_THREAD_PRIO_PROTECT,
+    _SC_THREAD_PROCESS_SHARED,
+    _SC_NPROCESSORS_CONF,
+    _SC_NPROCESSORS_ONLN,
+    _SC_PHYS_PAGES,
+    _SC_AVPHYS_PAGES,
+    _SC_ATEXIT_MAX,
+    _SC_PASS_MAX,
+    _SC_XOPEN_VERSION,
+    _SC_XOPEN_XCU_VERSION,
+    _SC_XOPEN_UNIX,
+    _SC_XOPEN_CRYPT,
+    _SC_XOPEN_ENH_I18N,
+    _SC_XOPEN_SHM,
+    _SC_2_CHAR_TERM,
+    _SC_2_C_VERSION,
+    _SC_2_UPE,
+    _SC_XOPEN_XPG2,
+    _SC_XOPEN_XPG3,
+    _SC_XOPEN_XPG4,
+    _SC_CHAR_BIT,
+    _SC_CHAR_MAX,
+    _SC_CHAR_MIN,
+    _SC_INT_MAX,
+    _SC_INT_MIN,
+    _SC_LONG_BIT,
+    _SC_WORD_BIT,
+    _SC_MB_LEN_MAX,
+    _SC_NZERO,
+    _SC_SSIZE_MAX,
+    _SC_SCHAR_MAX,
+    _SC_SCHAR_MIN,
+    _SC_SHRT_MAX,
+    _SC_SHRT_MIN,
+    _SC_UCHAR_MAX,
+    _SC_UINT_MAX,
+    _SC_ULONG_MAX,
+    _SC_USHRT_MAX,
+    _SC_NL_ARGMAX,
+    _SC_NL_LANGMAX,
+    _SC_NL_MSGMAX,
+    _SC_NL_NMAX,
+    _SC_NL_SETMAX,
+    _SC_NL_TEXTMAX,
+    _SC_XBS5_ILP32_OFF32,
+    _SC_XBS5_ILP32_OFFBIG,
+    _SC_XBS5_LP64_OFF64,
+    _SC_XBS5_LPBIG_OFFBIG,
+    _SC_XOPEN_LEGACY,
+    _SC_XOPEN_REALTIME,
+    _SC_XOPEN_REALTIME_THREADS,
+    _SC_ADVISORY_INFO,
+    _SC_BARRIERS,
+    _SC_BASE,
+    _SC_C_LANG_SUPPORT,
+    _SC_C_LANG_SUPPORT_R,
+    _SC_CLOCK_SELECTION,
+    _SC_CPUTIME,
+    _SC_THREAD_CPUTIME,
+    _SC_DEVICE_IO,
+    _SC_DEVICE_SPECIFIC,
+    _SC_DEVICE_SPECIFIC_R,
+    _SC_FD_MGMT,
+    _SC_FIFO,
+    _SC_PIPE,
+    _SC_FILE_ATTRIBUTES,
+    _SC_FILE_LOCKING,
+    _SC_FILE_SYSTEM,
+    _SC_MONOTONIC_CLOCK,
+    _SC_MULTI_PROCESS,
+    _SC_SINGLE_PROCESS,
+    _SC_NETWORKING,
+    _SC_READER_WRITER_LOCKS,
+    _SC_SPIN_LOCKS,
+    _SC_REGEXP,
+    _SC_REGEX_VERSION,
+    _SC_SHELL,
+    _SC_SIGNALS,
+    _SC_SPAWN,
+    _SC_SPORADIC_SERVER,
+    _SC_THREAD_SPORADIC_SERVER,
+    _SC_SYSTEM_DATABASE,
+    _SC_SYSTEM_DATABASE_R,
+    _SC_TIMEOUTS,
+    _SC_TYPED_MEMORY_OBJECTS,
+    _SC_USER_GROUPS,
+    _SC_USER_GROUPS_R,
+    _SC_2_PBS,
+    _SC_2_PBS_ACCOUNTING,
+    _SC_2_PBS_LOCATE,
+    _SC_2_PBS_MESSAGE,
+    _SC_2_PBS_TRACK,
+    _SC_SYMLOOP_MAX,
+    _SC_STREAMS,
+    _SC_2_PBS_CHECKPOINT,
+    _SC_V6_ILP32_OFF32,
+    _SC_V6_ILP32_OFFBIG,
+    _SC_V6_LP64_OFF64,
+    _SC_V6_LPBIG_OFFBIG,
+    _SC_HOST_NAME_MAX,
+    _SC_TRACE,
+    _SC_TRACE_EVENT_FILTER,
+    _SC_TRACE_INHERIT,
+    _SC_TRACE_LOG,
+    _SC_LEVEL1_ICACHE_SIZE,
+    _SC_LEVEL1_ICACHE_ASSOC,
+    _SC_LEVEL1_ICACHE_LINESIZE,
+    _SC_LEVEL1_DCACHE_SIZE,
+    _SC_LEVEL1_DCACHE_ASSOC,
+    _SC_LEVEL1_DCACHE_LINESIZE,
+    _SC_LEVEL2_CACHE_SIZE,
+    _SC_LEVEL2_CACHE_ASSOC,
+    _SC_LEVEL2_CACHE_LINESIZE,
+    _SC_LEVEL3_CACHE_SIZE,
+    _SC_LEVEL3_CACHE_ASSOC,
+    _SC_LEVEL3_CACHE_LINESIZE,
+    _SC_LEVEL4_CACHE_SIZE,
+    _SC_LEVEL4_CACHE_ASSOC,
+    _SC_LEVEL4_CACHE_LINESIZE,
+    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
+    _SC_RAW_SOCKETS,
+    _SC_V7_ILP32_OFF32,
+    _SC_V7_ILP32_OFFBIG,
+    _SC_V7_LP64_OFF64,
+    _SC_V7_LPBIG_OFFBIG,
+    _SC_SS_REPL_MAX,
+    _SC_TRACE_EVENT_NAME_MAX,
+    _SC_TRACE_NAME_MAX,
+    _SC_TRACE_SYS_MAX,
+    _SC_TRACE_USER_EVENT_MAX,
+    _SC_XOPEN_STREAMS,
+    _SC_THREAD_ROBUST_PRIO_INHERIT,
+    _SC_THREAD_ROBUST_PRIO_PROTECT
+  };
+enum
+  {
+    _CS_PATH,
+    _CS_V6_WIDTH_RESTRICTED_ENVS,
+    _CS_GNU_LIBC_VERSION,
+    _CS_GNU_LIBPTHREAD_VERSION,
+    _CS_V5_WIDTH_RESTRICTED_ENVS,
+    _CS_V7_WIDTH_RESTRICTED_ENVS,
+    _CS_LFS_CFLAGS = 1000,
+    _CS_LFS_LDFLAGS,
+    _CS_LFS_LIBS,
+    _CS_LFS_LINTFLAGS,
+    _CS_LFS64_CFLAGS,
+    _CS_LFS64_LDFLAGS,
+    _CS_LFS64_LIBS,
+    _CS_LFS64_LINTFLAGS,
+    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
+    _CS_XBS5_ILP32_OFF32_LDFLAGS,
+    _CS_XBS5_ILP32_OFF32_LIBS,
+    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
+    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
+    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
+    _CS_XBS5_ILP32_OFFBIG_LIBS,
+    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
+    _CS_XBS5_LP64_OFF64_CFLAGS,
+    _CS_XBS5_LP64_OFF64_LDFLAGS,
+    _CS_XBS5_LP64_OFF64_LIBS,
+    _CS_XBS5_LP64_OFF64_LINTFLAGS,
+    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
+    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
+    _CS_XBS5_LPBIG_OFFBIG_LIBS,
+    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
+    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
+    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
+    _CS_POSIX_V6_ILP32_OFF32_LIBS,
+    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
+    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
+    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
+    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
+    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
+    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
+    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
+    _CS_POSIX_V6_LP64_OFF64_LIBS,
+    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
+    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
+    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
+    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
+    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
+    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
+    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
+    _CS_POSIX_V7_ILP32_OFF32_LIBS,
+    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
+    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
+    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
+    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
+    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
+    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
+    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
+    _CS_POSIX_V7_LP64_OFF64_LIBS,
+    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
+    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
+    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
+    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
+    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
+    _CS_V6_ENV,
+    _CS_V7_ENV
+  };
+extern long int pathconf (__const char *__path, int __name)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern long int fpathconf (int __fd, int __name) throw ();
+extern long int sysconf (int __name) throw ();
+extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
+extern __pid_t getpid (void) throw ();
+extern __pid_t getppid (void) throw ();
+extern __pid_t getpgrp (void) throw ();
+extern __pid_t __getpgid (__pid_t __pid) throw ();
+extern __pid_t getpgid (__pid_t __pid) throw ();
+extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
+extern int setpgrp (void) throw ();
+extern __pid_t setsid (void) throw ();
+extern __pid_t getsid (__pid_t __pid) throw ();
+extern __uid_t getuid (void) throw ();
+extern __uid_t geteuid (void) throw ();
+extern __gid_t getgid (void) throw ();
+extern __gid_t getegid (void) throw ();
+extern int getgroups (int __size, __gid_t __list[]) throw () __attribute__ ((__warn_unused_result__));
+extern int group_member (__gid_t __gid) throw ();
+extern int setuid (__uid_t __uid) throw ();
+extern int setreuid (__uid_t __ruid, __uid_t __euid) throw ();
+extern int seteuid (__uid_t __uid) throw ();
+extern int setgid (__gid_t __gid) throw ();
+extern int setregid (__gid_t __rgid, __gid_t __egid) throw ();
+extern int setegid (__gid_t __gid) throw ();
+extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
+     throw ();
+extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
+     throw ();
+extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
+     throw ();
+extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
+     throw ();
+extern __pid_t fork (void) throw ();
+extern __pid_t vfork (void) throw ();
+extern char *ttyname (int __fd) throw ();
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+extern int isatty (int __fd) throw ();
+extern int ttyslot (void) throw ();
+extern int link (__const char *__from, __const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern int linkat (int __fromfd, __const char *__from, int __tofd,
+     __const char *__to, int __flags)
+     throw () __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
+extern int symlink (__const char *__from, __const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern ssize_t readlink (__const char *__restrict __path,
+    char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern int symlinkat (__const char *__from, int __tofd,
+        __const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+extern ssize_t readlinkat (int __fd, __const char *__restrict __path,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+extern int unlinkat (int __fd, __const char *__name, int __flag)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));
+extern __pid_t tcgetpgrp (int __fd) throw ();
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
+extern char *getlogin (void);
+extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
+extern int setlogin (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+extern "C" {
+extern char *optarg;
+extern int optind;
+extern int opterr;
+extern int optopt;
+extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
+       throw ();
+}
+extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
+extern int sethostname (__const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int sethostid (long int __id) throw () __attribute__ ((__warn_unused_result__));
+extern int getdomainname (char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int setdomainname (__const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int vhangup (void) throw ();
+extern int revoke (__const char *__file) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+     size_t __offset, unsigned int __scale)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int acct (__const char *__name) throw ();
+extern char *getusershell (void) throw ();
+extern void endusershell (void) throw ();
+extern void setusershell (void) throw ();
+extern int daemon (int __nochdir, int __noclose) throw () __attribute__ ((__warn_unused_result__));
+extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1)));
+extern int fsync (int __fd);
+extern int syncfs (int __fd) throw ();
+extern long int gethostid (void);
+extern void sync (void) throw ();
+extern int getpagesize (void) throw () __attribute__ ((__const__));
+extern int getdtablesize (void) throw ();
+extern int truncate (__const char *__file, __off_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int truncate64 (__const char *__file, __off64_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int ftruncate (int __fd, __off_t __length) throw () __attribute__ ((__warn_unused_result__));
+extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
+extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));
+extern void *sbrk (intptr_t __delta) throw ();
+extern long int syscall (long int __sysno, ...) throw ();
+extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__warn_unused_result__));
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
+extern int fdatasync (int __fildes);
+extern char *crypt (__const char *__key, __const char *__salt)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
+extern void swab (__const void *__restrict __from, void *__restrict __to,
+    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *ctermid (char *__s) throw ();
+extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
+      size_t __buflen) __attribute__ ((__warn_unused_result__));
+extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
+                               __attribute__ ((__warn_unused_result__));
+extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
+                                  ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+read (int __fd, void *__buf, size_t __nbytes)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
+      if (__nbytes > __builtin_object_size (__buf, 0))
+ return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
+    }
+  return __read_alias (__fd, __buf, __nbytes);
+}
+extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
+       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
+         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
+                                 __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
+                                     __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
+                                  ;
+extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
+                                  ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __pread_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
+      if ( __nbytes > __builtin_object_size (__buf, 0))
+ return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
+     __builtin_object_size (__buf, 0));
+    }
+  return __pread_alias (__fd, __buf, __nbytes, __offset);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
+      if ( __nbytes > __builtin_object_size (__buf, 0))
+ return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
+       __builtin_object_size (__buf, 0));
+    }
+  return __pread64_alias (__fd, __buf, __nbytes, __offset);
+}
+extern ssize_t __readlink_chk (__const char *__restrict __path,
+          char *__restrict __buf, size_t __len,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlink_alias (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlink")
+     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlink_chk_warn (__const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlink_chk")
+     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
+                                         ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
+__attribute__ ((__leaf__)) readlink (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+      if ( __len > __builtin_object_size (__buf, 2 > 1))
+ return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __readlink_alias (__path, __buf, __len);
+}
+extern ssize_t __readlinkat_chk (int __fd, __const char *__restrict __path,
+     char *__restrict __buf, size_t __len,
+     size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlinkat_alias (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlinkat")
+     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlinkat_chk_warn (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlinkat_chk")
+     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
+                ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
+__attribute__ ((__leaf__)) readlinkat (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+      if (__len > __builtin_object_size (__buf, 2 > 1))
+ return __readlinkat_chk_warn (__fd, __path, __buf, __len,
+          __builtin_object_size (__buf, 2 > 1));
+    }
+  return __readlinkat_alias (__fd, __path, __buf, __len);
+}
+extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
+     throw () __attribute__ ((__warn_unused_result__));
+extern char *__getcwd_alias (char *__buf, size_t __size) throw () __asm__ ("" "getcwd")
+                                              __attribute__ ((__warn_unused_result__));
+extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) throw () __asm__ ("" "__getcwd_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
+                              ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+__attribute__ ((__leaf__)) getcwd (char *__buf, size_t __size) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size))
+ return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));
+      if (__size > __builtin_object_size (__buf, 2 > 1))
+ return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getcwd_alias (__buf, __size);
+}
+extern char *__getwd_chk (char *__buf, size_t buflen)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *__getwd_warn (char *__buf) throw () __asm__ ("" "getwd")
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
+                                         ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
+__attribute__ ((__leaf__)) getwd (char *__buf) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
+  return __getwd_warn (__buf);
+}
+extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
+        size_t __buflen) throw ();
+extern size_t __confstr_alias (int __name, char *__buf, size_t __len) throw () __asm__ ("" "confstr")
+                             ;
+extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__confstr_chk")
+     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
+            ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) confstr (int __name, char *__buf, size_t __len) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+      if (__builtin_object_size (__buf, 2 > 1) < __len)
+ return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __confstr_alias (__name, __buf, __len);
+}
+extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
+     throw () __attribute__ ((__warn_unused_result__));
+extern int __getgroups_alias (int __size, __gid_t __list[]) throw () __asm__ ("" "getgroups")
+                 __attribute__ ((__warn_unused_result__));
+extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) throw () __asm__ ("" "__getgroups_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
+                                           ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) getgroups (int __size, __gid_t __list[]) throw ()
+{
+  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size) || __size < 0)
+ return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));
+      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
+ return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
+    }
+  return __getgroups_alias (__size, __list);
+}
+extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
+       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
+extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ttyname_r")
+     __attribute__ ((__nonnull__ (2)));
+extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ttyname_r_chk")
+     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
+                                  ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) ttyname_r (int __fd, char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __ttyname_r_alias (__fd, __buf, __buflen);
+}
+extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
+     __attribute__ ((__nonnull__ (1)));
+extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
+                     __attribute__ ((__nonnull__ (1)));
+extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
+     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
+                                  ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+getlogin_r (char *__buf, size_t __buflen)
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getlogin_r_alias (__buf, __buflen);
+}
+extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int __gethostname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "gethostname")
+                   __attribute__ ((__nonnull__ (1)));
+extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__gethostname_chk")
+     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
+                                  ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) gethostname (char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __gethostname_alias (__buf, __buflen);
+}
+extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int __getdomainname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "getdomainname")
+                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__getdomainname_chk")
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
+                    ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) getdomainname (char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getdomainname_alias (__buf, __buflen);
+}
+}
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &
+ __gthrw_pthread_cancel;
+  return __gthread_active_ptr != 0;
+}
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+static inline int
+__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
+        __gthread_recursive_mutex_t *__mutex,
+        const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+#pragma GCC visibility pop
+typedef int _Atomic_word;
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  static inline _Atomic_word
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __sync_fetch_and_add(__mem, __val); }
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __sync_fetch_and_add(__mem, __val); }
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+  }
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+  }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Alloc allocator_type;
+      typedef typename _CharT_alloc_type::size_type size_type;
+      typedef typename _CharT_alloc_type::difference_type difference_type;
+      typedef typename _CharT_alloc_type::reference reference;
+      typedef typename _CharT_alloc_type::const_reference const_reference;
+      typedef typename _CharT_alloc_type::pointer pointer;
+      typedef typename _CharT_alloc_type::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+                                                            const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+    private:
+      struct _Rep_base
+      {
+ size_type _M_length;
+ size_type _M_capacity;
+ _Atomic_word _M_refcount;
+      };
+      struct _Rep : _Rep_base
+      {
+ typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
+ static const size_type _S_max_size;
+ static const _CharT _S_terminal;
+        static size_type _S_empty_rep_storage[];
+        static _Rep&
+        _S_empty_rep()
+        {
+   void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
+   return *reinterpret_cast<_Rep*>(__p);
+ }
+        bool
+ _M_is_leaked() const
+        { return this->_M_refcount < 0; }
+        bool
+ _M_is_shared() const
+        { return this->_M_refcount > 0; }
+        void
+ _M_set_leaked()
+        { this->_M_refcount = -1; }
+        void
+ _M_set_sharable()
+        { this->_M_refcount = 0; }
+ void
+ _M_set_length_and_sharable(size_type __n)
+ {
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+     {
+       this->_M_set_sharable();
+       this->_M_length = __n;
+       traits_type::assign(this->_M_refdata()[__n], _S_terminal);
+     }
+ }
+ _CharT*
+ _M_refdata() throw()
+ { return reinterpret_cast<_CharT*>(this + 1); }
+ _CharT*
+ _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
+ {
+   return (!_M_is_leaked() && __alloc1 == __alloc2)
+           ? _M_refcopy() : _M_clone(__alloc1);
+ }
+ static _Rep*
+ _S_create(size_type, size_type, const _Alloc&);
+ void
+ _M_dispose(const _Alloc& __a)
+ {
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+     {
+       ;
+       if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
+        -1) <= 0)
+  {
+    ;
+    _M_destroy(__a);
+  }
+     }
+ }
+ void
+ _M_destroy(const _Alloc&) throw();
+ _CharT*
+ _M_refcopy() throw()
+ {
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
+   return _M_refdata();
+ }
+ _CharT*
+ _M_clone(const _Alloc&, size_type __res = 0);
+      };
+      struct _Alloc_hider : _Alloc
+      {
+ _Alloc_hider(_CharT* __dat, const _Alloc& __a)
+ : _Alloc(__a), _M_p(__dat) { }
+ _CharT* _M_p;
+      };
+    public:
+      static const size_type npos = static_cast<size_type>(-1);
+    private:
+      mutable _Alloc_hider _M_dataplus;
+      _CharT*
+      _M_data() const
+      { return _M_dataplus._M_p; }
+      _CharT*
+      _M_data(_CharT* __p)
+      { return (_M_dataplus._M_p = __p); }
+      _Rep*
+      _M_rep() const
+      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
+      iterator
+      _M_ibegin() const
+      { return iterator(_M_data()); }
+      iterator
+      _M_iend() const
+      { return iterator(_M_data() + this->size()); }
+      void
+      _M_leak()
+      {
+ if (!_M_rep()->_M_is_leaked())
+   _M_leak_hard();
+      }
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range((__s));
+ return __pos;
+      }
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+      size_type
+      _M_limit(size_type __pos, size_type __off) const
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+      bool
+      _M_disjunct(const _CharT* __s) const
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+      static void
+      _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+      static void
+      _M_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+      static void
+      _M_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, ++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
+      { _M_copy(__p, __k1, __k2 - __k1); }
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      { _M_copy(__p, __k1, __k2 - __k1); }
+      static int
+      _S_compare(size_type __n1, size_type __n2)
+      {
+ const difference_type __d = difference_type(__n1 - __n2);
+ if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+   return __gnu_cxx::__numeric_traits<int>::__max;
+ else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+   return __gnu_cxx::__numeric_traits<int>::__min;
+ else
+   return int(__d);
+      }
+      void
+      _M_mutate(size_type __pos, size_type __len1, size_type __len2);
+      void
+      _M_leak_hard();
+      static _Rep&
+      _S_empty_rep()
+      { return _Rep::_S_empty_rep(); }
+    public:
+      basic_string()
+      : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
+      explicit
+      basic_string(const _Alloc& __a);
+      basic_string(const basic_string& __str);
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n = npos);
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a);
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc());
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
+      template<class _InputIterator>
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc());
+      ~basic_string()
+      { _M_rep()->_M_dispose(this->get_allocator()); }
+      basic_string&
+      operator=(const basic_string& __str)
+      { return this->assign(__str); }
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+      iterator
+      begin()
+      {
+ _M_leak();
+ return iterator(_M_data());
+      }
+      const_iterator
+      begin() const
+      { return const_iterator(_M_data()); }
+      iterator
+      end()
+      {
+ _M_leak();
+ return iterator(_M_data() + this->size());
+      }
+      const_iterator
+      end() const
+      { return const_iterator(_M_data() + this->size()); }
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(this->end()); }
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(this->end()); }
+      reverse_iterator
+      rend()
+      { return reverse_iterator(this->begin()); }
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(this->begin()); }
+    public:
+      size_type
+      size() const
+      { return _M_rep()->_M_length; }
+      size_type
+      length() const
+      { return _M_rep()->_M_length; }
+      size_type
+      max_size() const
+      { return _Rep::_S_max_size; }
+      void
+      resize(size_type __n, _CharT __c);
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+      size_type
+      capacity() const
+      { return _M_rep()->_M_capacity; }
+      void
+      reserve(size_type __res_arg = 0);
+      void
+      clear()
+      { _M_mutate(0, this->size(), 0); }
+      bool
+      empty() const
+      { return this->size() == 0; }
+      const_reference
+      operator[] (size_type __pos) const
+      {
+ ;
+ return _M_data()[__pos];
+      }
+      reference
+      operator[](size_type __pos)
+      {
+ ;
+ ;
+ _M_leak();
+ return _M_data()[__pos];
+      }
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range(("basic_string::at"));
+ return _M_data()[__n];
+      }
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range(("basic_string::at"));
+ _M_leak();
+ return _M_data()[__n];
+      }
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+      basic_string&
+      append(const basic_string& __str);
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n);
+      basic_string&
+      append(const _CharT* __s, size_type __n);
+      basic_string&
+      append(const _CharT* __s)
+      {
+ ;
+ return this->append(__s, traits_type::length(__s));
+      }
+      basic_string&
+      append(size_type __n, _CharT __c);
+      template<class _InputIterator>
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_iend(), _M_iend(), __first, __last); }
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __len = 1 + this->size();
+ if (__len > this->capacity() || _M_rep()->_M_is_shared())
+   this->reserve(__len);
+ traits_type::assign(_M_data()[this->size()], __c);
+ _M_rep()->_M_set_length_and_sharable(__len);
+      }
+      basic_string&
+      assign(const basic_string& __str);
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n)
+      { return this->assign(__str._M_data()
+       + __str._M_check(__pos, "basic_string::assign"),
+       __str._M_limit(__pos, __n)); }
+      basic_string&
+      assign(const _CharT* __s, size_type __n);
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return this->assign(__s, traits_type::length(__s));
+      }
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+      template<class _InputIterator>
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
+      void
+      insert(iterator __p, size_type __n, _CharT __c)
+      { this->replace(__p, __p, __n, __c); }
+      template<class _InputIterator>
+        void
+        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
+        { this->replace(__p, __p, __beg, __end); }
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n)
+      { return this->insert(__pos1, __str._M_data()
+       + __str._M_check(__pos2, "basic_string::insert"),
+       __str._M_limit(__pos2, __n)); }
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n);
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+ ;
+ return this->insert(__pos, __s, traits_type::length(__s));
+      }
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+      iterator
+      insert(iterator __p, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - _M_ibegin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ _M_rep()->_M_set_leaked();
+ return iterator(_M_data() + __pos);
+      }
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ _M_mutate(_M_check(__pos, "basic_string::erase"),
+    _M_limit(__pos, __n), size_type(0));
+ return *this;
+      }
+      iterator
+      erase(iterator __position)
+      {
+                               ;
+ const size_type __pos = __position - _M_ibegin();
+ _M_mutate(__pos, size_type(1), size_type(0));
+ _M_rep()->_M_set_leaked();
+ return iterator(_M_data() + __pos);
+      }
+      iterator
+      erase(iterator __first, iterator __last);
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2);
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+      basic_string&
+      replace(iterator __i1, iterator __i2, const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
+      {
+                          ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
+      }
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s)
+      {
+ ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+      basic_string&
+      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
+      {
+                          ;
+ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
+      }
+      template<class _InputIterator>
+        basic_string&
+        replace(iterator __i1, iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+                            ;
+   ;
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
+ }
+      basic_string&
+      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
+      {
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+      basic_string&
+      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
+      {
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
+       _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+       _InputIterator __k2, __false_type);
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+      basic_string&
+      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+        size_type __n2);
+      template<class _InIterator>
+        static _CharT*
+        _S_construct_aux(_InIterator __beg, _InIterator __end,
+    const _Alloc& __a, __false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          return _S_construct(__beg, __end, __a, _Tag());
+ }
+      template<class _Integer>
+        static _CharT*
+        _S_construct_aux(_Integer __beg, _Integer __end,
+    const _Alloc& __a, __true_type)
+        { return _S_construct_aux_2(static_cast<size_type>(__beg),
+        __end, __a); }
+      static _CharT*
+      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
+      { return _S_construct(__req, __c, __a); }
+      template<class _InIterator>
+        static _CharT*
+        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   return _S_construct_aux(__beg, __end, __a, _Integral());
+        }
+      template<class _InIterator>
+        static _CharT*
+         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+        input_iterator_tag);
+      template<class _FwdIterator>
+        static _CharT*
+        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
+       forward_iterator_tag);
+      static _CharT*
+      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
+    public:
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+      void
+      swap(basic_string& __s);
+      const _CharT*
+      c_str() const
+      { return _M_data(); }
+      const _CharT*
+      data() const
+      { return _M_data(); }
+      allocator_type
+      get_allocator() const
+      { return _M_dataplus; }
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+      { return this->find(__str.data(), __pos, __str.size()); }
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find(_CharT __c, size_type __pos = 0) const;
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const;
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const
+      { return this->find(__c, __pos); }
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const
+      { return this->rfind(__c, __pos); }
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const;
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const;
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const;
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const;
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2) const;
+      int
+      compare(const _CharT* __s) const;
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+  };
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+      const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+        const basic_string<_CharT>& __rhs)
+    { return (__lhs.size() == __rhs.size()
+       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+          __lhs.size())); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return getline(__is, __str, __is.widen('\n')); }
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+     char __delim);
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+     wchar_t __delim);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const _CharT
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_terminal = _CharT();
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
+    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
+      sizeof(size_type)];
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+     input_iterator_tag)
+      {
+ if (__beg == __end && __a == _Alloc())
+   return _S_empty_rep()._M_refdata();
+ _CharT __buf[128];
+ size_type __len = 0;
+ while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
+   {
+     __buf[__len++] = *__beg;
+     ++__beg;
+   }
+ _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
+ _M_copy(__r->_M_refdata(), __buf, __len);
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __r->_M_capacity)
+    {
+      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
+      _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
+      __r->_M_destroy(__a);
+      __r = __another;
+    }
+  __r->_M_refdata()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     __r->_M_destroy(__a);
+     throw;
+   }
+ __r->_M_set_length_and_sharable(__len);
+ return __r->_M_refdata();
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template <typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+     forward_iterator_tag)
+      {
+ if (__beg == __end && __a == _Alloc())
+   return _S_empty_rep()._M_refdata();
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   __throw_logic_error(("basic_string::_S_construct null not valid"));
+ const size_type __dnew = static_cast<size_type>(std::distance(__beg,
+              __end));
+ _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
+ try
+   { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
+ catch(...)
+   {
+     __r->_M_destroy(__a);
+     throw;
+   }
+ __r->_M_set_length_and_sharable(__dnew);
+ return __r->_M_refdata();
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::
+    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
+    {
+      if (__n == 0 && __a == _Alloc())
+ return _S_empty_rep()._M_refdata();
+      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
+      if (__n)
+ _M_assign(__r->_M_refdata(), __n, __c);
+      __r->_M_set_length_and_sharable(__n);
+      return __r->_M_refdata();
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str)
+    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
+       __str.get_allocator()),
+    __str.get_allocator())
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _Alloc& __a)
+    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos, size_type __n)
+    : _M_dataplus(_S_construct(__str._M_data()
+          + __str._M_check(__pos,
+      "basic_string::basic_string"),
+          __str._M_data() + __str._M_limit(__pos, __n)
+          + __pos, _Alloc()), _Alloc())
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos,
+   size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__str._M_data()
+          + __str._M_check(__pos,
+      "basic_string::basic_string"),
+          __str._M_data() + __str._M_limit(__pos, __n)
+          + __pos, __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
+          __s + npos, __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__n, __c, __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
+    { }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const basic_string& __str)
+    {
+      if (_M_rep() != __str._M_rep())
+ {
+   const allocator_type __a = this->get_allocator();
+   _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
+   _M_rep()->_M_dispose(__a);
+   _M_data(__tmp);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const _CharT* __s, size_type __n)
+    {
+      ;
+      _M_check_length(this->size(), __n, "basic_string::assign");
+      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+ return _M_replace_safe(size_type(0), this->size(), __s, __n);
+      else
+ {
+   const size_type __pos = __s - _M_data();
+   if (__pos >= __n)
+     _M_copy(_M_data(), __s, __n);
+   else if (__pos)
+     _M_move(_M_data(), __s, __n);
+   _M_rep()->_M_set_length_and_sharable(__n);
+   return *this;
+ }
+     }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(size_type __n, _CharT __c)
+    {
+      if (__n)
+ {
+   _M_check_length(size_type(0), __n, "basic_string::append");
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_assign(_M_data() + this->size(), __n, __c);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const _CharT* __s, size_type __n)
+    {
+      ;
+      if (__n)
+ {
+   _M_check_length(size_type(0), __n, "basic_string::append");
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     {
+       if (_M_disjunct(__s))
+  this->reserve(__len);
+       else
+  {
+    const size_type __off = __s - _M_data();
+    this->reserve(__len);
+    __s = _M_data() + __off;
+  }
+     }
+   _M_copy(_M_data() + this->size(), __s, __n);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str)
+    {
+      const size_type __size = __str.size();
+      if (__size)
+ {
+   const size_type __len = __size + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_copy(_M_data() + this->size(), __str._M_data(), __size);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      __str._M_check(__pos, "basic_string::append");
+      __n = __str._M_limit(__pos, __n);
+      if (__n)
+ {
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     insert(size_type __pos, const _CharT* __s, size_type __n)
+     {
+       ;
+       _M_check(__pos, "basic_string::insert");
+       _M_check_length(size_type(0), __n, "basic_string::insert");
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, size_type(0), __s, __n);
+       else
+         {
+           const size_type __off = __s - _M_data();
+           _M_mutate(__pos, 0, __n);
+           __s = _M_data() + __off;
+           _CharT* __p = _M_data() + __pos;
+           if (__s + __n <= __p)
+             _M_copy(__p, __s, __n);
+           else if (__s >= __p)
+             _M_copy(__p, __s + __n, __n);
+           else
+             {
+        const size_type __nleft = __p - __s;
+               _M_copy(__p, __s, __nleft);
+               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
+             }
+           return *this;
+         }
+     }
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     typename basic_string<_CharT, _Traits, _Alloc>::iterator
+     basic_string<_CharT, _Traits, _Alloc>::
+     erase(iterator __first, iterator __last)
+     {
+                           ;
+       const size_type __size = __last - __first;
+       if (__size)
+  {
+    const size_type __pos = __first - _M_ibegin();
+    _M_mutate(__pos, __size, size_type(0));
+    _M_rep()->_M_set_leaked();
+    return iterator(_M_data() + __pos);
+  }
+       else
+  return __first;
+     }
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     replace(size_type __pos, size_type __n1, const _CharT* __s,
+      size_type __n2)
+     {
+       ;
+       _M_check(__pos, "basic_string::replace");
+       __n1 = _M_limit(__pos, __n1);
+       _M_check_length(__n1, __n2, "basic_string::replace");
+       bool __left;
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, __n1, __s, __n2);
+       else if ((__left = __s + __n2 <= _M_data() + __pos)
+  || _M_data() + __pos + __n1 <= __s)
+  {
+    size_type __off = __s - _M_data();
+    __left ? __off : (__off += __n2 - __n1);
+    _M_mutate(__pos, __n1, __n2);
+    _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
+    return *this;
+  }
+       else
+  {
+    const basic_string __tmp(__s, __n2);
+    return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
+  }
+     }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_destroy(const _Alloc& __a) throw ()
+    {
+      const size_type __size = sizeof(_Rep_base) +
+                        (this->_M_capacity + 1) * sizeof(_CharT);
+      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_leak_hard()
+    {
+      if (_M_rep() == &_S_empty_rep())
+ return;
+      if (_M_rep()->_M_is_shared())
+ _M_mutate(0, 0, 0);
+      _M_rep()->_M_set_leaked();
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
+    {
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+      const size_type __how_much = __old_size - __pos - __len1;
+      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
+ {
+   const allocator_type __a = get_allocator();
+   _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
+   if (__pos)
+     _M_copy(__r->_M_refdata(), _M_data(), __pos);
+   if (__how_much)
+     _M_copy(__r->_M_refdata() + __pos + __len2,
+      _M_data() + __pos + __len1, __how_much);
+   _M_rep()->_M_dispose(__a);
+   _M_data(__r->_M_refdata());
+ }
+      else if (__how_much && __len1 != __len2)
+ {
+   _M_move(_M_data() + __pos + __len2,
+    _M_data() + __pos + __len1, __how_much);
+ }
+      _M_rep()->_M_set_length_and_sharable(__new_size);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+      if (__res != this->capacity() || _M_rep()->_M_is_shared())
+        {
+   if (__res < this->size())
+     __res = this->size();
+   const allocator_type __a = get_allocator();
+   _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
+   _M_rep()->_M_dispose(__a);
+   _M_data(__tmp);
+        }
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s)
+    {
+      if (_M_rep()->_M_is_leaked())
+ _M_rep()->_M_set_sharable();
+      if (__s._M_rep()->_M_is_leaked())
+ __s._M_rep()->_M_set_sharable();
+      if (this->get_allocator() == __s.get_allocator())
+ {
+   _CharT* __tmp = _M_data();
+   _M_data(__s._M_data());
+   __s._M_data(__tmp);
+ }
+      else
+ {
+   const basic_string __tmp1(_M_ibegin(), _M_iend(),
+        __s.get_allocator());
+   const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
+        this->get_allocator());
+   *this = __tmp2;
+   __s = __tmp1;
+ }
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _S_create(size_type __capacity, size_type __old_capacity,
+       const _Alloc& __alloc)
+    {
+      if (__capacity > _S_max_size)
+ __throw_length_error(("basic_string::_S_create"));
+      const size_type __pagesize = 4096;
+      const size_type __malloc_header_size = 4 * sizeof(void*);
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ __capacity = 2 * __old_capacity;
+      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+      const size_type __adj_size = __size + __malloc_header_size;
+      if (__adj_size > __pagesize && __capacity > __old_capacity)
+ {
+   const size_type __extra = __pagesize - __adj_size % __pagesize;
+   __capacity += __extra / sizeof(_CharT);
+   if (__capacity > _S_max_size)
+     __capacity = _S_max_size;
+   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+ }
+      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
+      _Rep *__p = new (__place) _Rep;
+      __p->_M_capacity = __capacity;
+      __p->_M_set_sharable();
+      return __p;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_clone(const _Alloc& __alloc, size_type __res)
+    {
+      const size_type __requested_cap = this->_M_length + __res;
+      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
+      __alloc);
+      if (this->_M_length)
+ _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
+      __r->_M_set_length_and_sharable(this->_M_length);
+      return __r->_M_refdata();
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      _M_check_length(__size, __n, "basic_string::resize");
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->erase(__n);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+     _InputIterator __k2, __false_type)
+      {
+ const basic_string __s(__k1, __k2);
+ const size_type __n1 = __i2 - __i1;
+ _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
+ return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
+          __s.size());
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+ _M_assign(_M_data() + __pos1, __n2, __c);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+      size_type __n2)
+    {
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+ _M_copy(_M_data() + __pos1, __s, __n2);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      ;
+      if (__n)
+ _M_copy(__s, _M_data() + __pos, __n);
+      return __n;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      const size_type __size = this->size();
+      const _CharT* __data = _M_data();
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+      if (__n <= __size)
+ {
+   for (; __pos <= __size - __n; ++__pos)
+     if (traits_type::eq(__data[__pos], __s[0])
+  && traits_type::compare(__data + __pos + 1,
+     __s + 1, __n - 1) == 0)
+       return __pos;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+ {
+   const _CharT* __data = _M_data();
+   const size_type __n = __size - __pos;
+   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+   if (__p)
+     __ret = __p - __data;
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      const size_type __size = this->size();
+      if (__n <= __size)
+ {
+   __pos = std::min(size_type(__size - __n), __pos);
+   const _CharT* __data = _M_data();
+   do
+     {
+       if (traits_type::compare(__data + __pos, __s, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(_M_data()[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      for (; __n && __pos < this->size(); ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::find(__s, __n, _M_data()[__pos]))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const
+    {
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::eq(_M_data()[__pos], __c))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(_M_data()[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+ __r = _S_compare(__n, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+     size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+         __str.data() + __pos2, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const
+    {
+      ;
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+ __r = _S_compare(__size, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+     size_type __n2) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+        basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef typename __ctype_type::ctype_base __ctype_base;
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       _CharT __buf[128];
+       __size_type __len = 0;
+       const streamsize __w = __in.width();
+       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+                                : __str.max_size();
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(__ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    if (__len == sizeof(__buf) / sizeof(_CharT))
+      {
+        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+        __len = 0;
+      }
+    __buf[__len++] = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       __str.append(__buf, __len);
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       const __int_type __idelim = _Traits::to_int_type(__delim);
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !_Traits::eq_int_type(__c, __idelim))
+  {
+    __str += _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       else if (_Traits::eq_int_type(__c, __idelim))
+  {
+    ++__extracted;
+    __in.rdbuf()->sbumpc();
+  }
+       else
+  __err |= __ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  extern template class basic_string<char>;
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+  extern template class basic_string<wchar_t>;
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _T1, typename _T2>
+    inline void
+    _Construct(_T1* __p, const _T2& __value)
+    {
+      ::new(static_cast<void*>(__p)) _T1(__value);
+    }
+  template<typename _Tp>
+    inline void
+    _Destroy(_Tp* __pointer)
+    { __pointer->~_Tp(); }
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator __first, _ForwardIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     std::_Destroy(std::__addressof(*__first));
+ }
+    };
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+  template <typename _Tp> class allocator;
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      for (; __first != __last; ++__first)
+ __alloc.destroy(std::__addressof(*__first));
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<bool _TrivialValueTypes>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        {
+   _ForwardIterator __cur = __result;
+   try
+     {
+       for (; __first != __last; ++__first, ++__cur)
+  std::_Construct(std::__addressof(*__cur), *__first);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__result, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+      return std::__uninitialized_copy<(__is_trivial(_ValueType1)
+     && __is_trivial(_ValueType2))>::
+ __uninit_copy(__first, __last, __result);
+    }
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      std::__uninitialized_fill<__is_trivial(_ValueType)>::
+ __uninit_fill(__first, __last, __x);
+    }
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        { std::fill_n(__first, __n, __x); }
+    };
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline void
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      std::__uninitialized_fill_n<__is_trivial(_ValueType)>::
+ __uninit_fill_n(__first, __n, __x);
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __first != __last; ++__first, ++__cur)
+     __alloc.construct(std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a((__first),
+      (__last),
+      __result, __alloc);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   for (; __cur != __last; ++__cur)
+     __alloc.construct(std::__addressof(*__cur), __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Allocator>
+    void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   for (; __n > 0; --__n, ++__cur)
+     __alloc.construct(std::__addressof(*__cur), __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill_n(__first, __n, __x); }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+      struct _Vector_impl
+      : public _Tp_alloc_type
+      {
+ typename _Tp_alloc_type::pointer _M_start;
+ typename _Tp_alloc_type::pointer _M_finish;
+ typename _Tp_alloc_type::pointer _M_end_of_storage;
+ _Vector_impl()
+ : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+ { }
+ _Vector_impl(_Tp_alloc_type const& __a)
+ : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+ { }
+      };
+    public:
+      typedef _Alloc allocator_type;
+      _Tp_alloc_type&
+      _M_get_Tp_allocator()
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Tp_allocator()); }
+      _Vector_base()
+      : _M_impl() { }
+      _Vector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+      _Vector_base(size_t __n)
+      : _M_impl()
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+      ~_Vector_base()
+      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
+        - this->_M_impl._M_start); }
+    public:
+      _Vector_impl _M_impl;
+      typename _Tp_alloc_type::pointer
+      _M_allocate(size_t __n)
+      { return __n != 0 ? _M_impl.allocate(__n) : 0; }
+      void
+      _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n)
+      {
+ if (__p)
+   _M_impl.deallocate(__p, __n);
+      }
+    };
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+      typedef typename _Alloc::value_type _Alloc_value_type;
+      typedef _Vector_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_type::pointer pointer;
+      typedef typename _Tp_alloc_type::const_pointer const_pointer;
+      typedef typename _Tp_alloc_type::reference reference;
+      typedef typename _Tp_alloc_type::const_reference const_reference;
+      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+    public:
+      vector()
+      : _Base() { }
+      explicit
+      vector(const allocator_type& __a)
+      : _Base(__a) { }
+      explicit
+      vector(size_type __n, const value_type& __value = value_type(),
+      const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+      vector(const vector& __x)
+      : _Base(__x.size(), __x._M_get_Tp_allocator())
+      { this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+      template<typename _InputIterator>
+        vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_initialize_dispatch(__first, __last, _Integral());
+ }
+      ~vector()
+      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator()); }
+      vector&
+      operator=(const vector& __x);
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_assign_dispatch(__first, __last, _Integral());
+ }
+      using _Base::get_allocator;
+      iterator
+      begin()
+      { return iterator(this->_M_impl._M_start); }
+      const_iterator
+      begin() const
+      { return const_iterator(this->_M_impl._M_start); }
+      iterator
+      end()
+      { return iterator(this->_M_impl._M_finish); }
+      const_iterator
+      end() const
+      { return const_iterator(this->_M_impl._M_finish); }
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+      size_type
+      size() const
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+      size_type
+      max_size() const
+      { return _M_get_Tp_allocator().max_size(); }
+      void
+      resize(size_type __new_size, value_type __x = value_type())
+      {
+ if (__new_size > size())
+   insert(end(), __new_size - size(), __x);
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+      size_type
+      capacity() const
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+      bool
+      empty() const
+      { return begin() == end(); }
+      void
+      reserve(size_type __n);
+      reference
+      operator[](size_type __n)
+      { return *(this->_M_impl._M_start + __n); }
+      const_reference
+      operator[](size_type __n) const
+      { return *(this->_M_impl._M_start + __n); }
+    protected:
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range(("vector::_M_range_check"));
+      }
+    public:
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      reference
+      front()
+      { return *begin(); }
+      const_reference
+      front() const
+      { return *begin(); }
+      reference
+      back()
+      { return *(end() - 1); }
+      const_reference
+      back() const
+      { return *(end() - 1); }
+      pointer
+      data()
+      { return std::__addressof(front()); }
+      const_pointer
+      data() const
+      { return std::__addressof(front()); }
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     this->_M_impl.construct(this->_M_impl._M_finish, __x);
+     ++this->_M_impl._M_finish;
+   }
+ else
+   _M_insert_aux(end(), __x);
+      }
+      void
+      pop_back()
+      {
+ --this->_M_impl._M_finish;
+ this->_M_impl.destroy(this->_M_impl._M_finish);
+      }
+      iterator
+      insert(iterator __position, const value_type& __x);
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_insert_dispatch(__position, __first, __last, _Integral());
+ }
+      iterator
+      erase(iterator __position);
+      iterator
+      erase(iterator __first, iterator __last);
+      void
+      swap(vector& __x)
+      {
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_end_of_storage,
+    __x._M_impl._M_end_of_storage);
+ std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
+          __x._M_get_Tp_allocator());
+      }
+      void
+      clear()
+      { _M_erase_at_end(this->_M_impl._M_start); }
+    protected:
+      template<typename _ForwardIterator>
+        pointer
+        _M_allocate_and_copy(size_type __n,
+        _ForwardIterator __first, _ForwardIterator __last)
+        {
+   pointer __result = this->_M_allocate(__n);
+   try
+     {
+       std::__uninitialized_copy_a(__first, __last, __result,
+       _M_get_Tp_allocator());
+       return __result;
+     }
+   catch(...)
+     {
+       _M_deallocate(__result, __n);
+       throw;
+     }
+ }
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
+        {
+   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
+   this->_M_impl._M_end_of_storage =
+     this->_M_impl._M_start + static_cast<size_type>(__n);
+   _M_fill_initialize(static_cast<size_type>(__n), __value);
+ }
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag)
+        {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag)
+        {
+   const size_type __n = std::distance(__first, __last);
+   this->_M_impl._M_start = this->_M_allocate(__n);
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+   this->_M_impl._M_finish =
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+ }
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+ std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+          _M_get_Tp_allocator());
+ this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
+      }
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_assign_aux(__first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag);
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+      __true_type)
+        { _M_fill_insert(__pos, __n, __val); }
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos, _InputIterator __first,
+      _InputIterator __last, __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_insert(__pos, __first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_range_insert(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag);
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert(iterator __pos, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+      void
+      _M_insert_aux(iterator __position, const value_type& __x);
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+      void
+      _M_erase_at_end(pointer __pos)
+      {
+ std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ this->_M_impl._M_finish = __pos;
+      }
+    };
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+    _Bit_reference() : _M_p(0), _M_mask(0) { }
+    operator bool() const
+    { return !!(*_M_p & _M_mask); }
+    _Bit_reference&
+    operator=(bool __x)
+    {
+      if (__x)
+ *_M_p |= _M_mask;
+      else
+ *_M_p &= ~_M_mask;
+      return *this;
+    }
+    _Bit_reference&
+    operator=(const _Bit_reference& __x)
+    { return *this = bool(__x); }
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+    void
+    flip()
+    { *_M_p ^= _M_mask; }
+  };
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+ {
+   _M_offset = 0;
+   ++_M_p;
+ }
+    }
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+ {
+   _M_offset = int(_S_word_bit) - 1;
+   --_M_p;
+ }
+    }
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+ {
+   __n += int(_S_word_bit);
+   --_M_p;
+ }
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+    bool
+    operator==(const _Bit_iterator_base& __i) const
+    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
+    bool
+    operator<(const _Bit_iterator_base& __i) const
+    {
+      return _M_p < __i._M_p
+      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
+    }
+    bool
+    operator!=(const _Bit_iterator_base& __i) const
+    { return !(*this == __i); }
+    bool
+    operator>(const _Bit_iterator_base& __i) const
+    { return __i < *this; }
+    bool
+    operator<=(const _Bit_iterator_base& __i) const
+    { return !(__i < *this); }
+    bool
+    operator>=(const _Bit_iterator_base& __i) const
+    { return !(*this < __i); }
+  };
+  inline ptrdiff_t
+  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+  {
+    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+     + __x._M_offset - __y._M_offset);
+  }
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference reference;
+    typedef _Bit_reference* pointer;
+    typedef _Bit_iterator iterator;
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+    iterator
+    operator+(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp += __i;
+    }
+    iterator
+    operator-(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+  inline _Bit_iterator
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool reference;
+    typedef bool const_reference;
+    typedef const bool* pointer;
+    typedef _Bit_const_iterator const_iterator;
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+    const_iterator
+    operator+(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp += __i;
+    }
+    const_iterator
+    operator-(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+  inline _Bit_const_iterator
+  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
+  { return __x + __n; }
+  inline void
+  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
+  {
+    for (; __first != __last; ++__first)
+      *__first = __x;
+  }
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
+ __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
+ __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
+      }
+    else
+      __fill_bvector(__first, __last, __x);
+  }
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename _Alloc::template rebind<_Bit_type>::other
+        _Bit_alloc_type;
+      struct _Bvector_impl
+      : public _Bit_alloc_type
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_type* _M_end_of_storage;
+ _Bvector_impl()
+ : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+ _Bvector_impl(const _Bit_alloc_type& __a)
+ : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+      };
+    public:
+      typedef _Alloc allocator_type;
+      _Bit_alloc_type&
+      _M_get_Bit_allocator()
+      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const
+      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Bit_allocator()); }
+      _Bvector_base()
+      : _M_impl() { }
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+    protected:
+      _Bvector_impl _M_impl;
+      _Bit_type*
+      _M_allocate(size_t __n)
+      { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
+    / int(_S_word_bit)); }
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   _M_impl.deallocate(_M_impl._M_start._M_p,
+        _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
+      }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+template<typename _Alloc>
+  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+  {
+    typedef _Bvector_base<_Alloc> _Base;
+  public:
+    typedef bool value_type;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Bit_reference reference;
+    typedef bool const_reference;
+    typedef _Bit_reference* pointer;
+    typedef const bool* const_pointer;
+    typedef _Bit_iterator iterator;
+    typedef _Bit_const_iterator const_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef _Alloc allocator_type;
+    allocator_type get_allocator() const
+    { return _Base::get_allocator(); }
+  protected:
+    using _Base::_M_allocate;
+    using _Base::_M_deallocate;
+    using _Base::_M_get_Bit_allocator;
+  public:
+    vector()
+    : _Base() { }
+    explicit
+    vector(const allocator_type& __a)
+    : _Base(__a) { }
+    explicit
+    vector(size_type __n, const bool& __value = bool(),
+    const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize(__n);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
+  __value ? ~0 : 0);
+    }
+    vector(const vector& __x)
+    : _Base(__x._M_get_Bit_allocator())
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+    template<typename _InputIterator>
+      vector(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+      }
+    ~vector() { }
+    vector&
+    operator=(const vector& __x)
+    {
+      if (&__x == this)
+ return *this;
+      if (__x.size() > capacity())
+ {
+   this->_M_deallocate();
+   _M_initialize(__x.size());
+ }
+      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+      begin());
+      return *this;
+    }
+    void
+    assign(size_type __n, const bool& __x)
+    { _M_fill_assign(__n, __x); }
+    template<typename _InputIterator>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+      }
+    iterator
+    begin()
+    { return this->_M_impl._M_start; }
+    const_iterator
+    begin() const
+    { return this->_M_impl._M_start; }
+    iterator
+    end()
+    { return this->_M_impl._M_finish; }
+    const_iterator
+    end() const
+    { return this->_M_impl._M_finish; }
+    reverse_iterator
+    rbegin()
+    { return reverse_iterator(end()); }
+    const_reverse_iterator
+    rbegin() const
+    { return const_reverse_iterator(end()); }
+    reverse_iterator
+    rend()
+    { return reverse_iterator(begin()); }
+    const_reverse_iterator
+    rend() const
+    { return const_reverse_iterator(begin()); }
+    size_type
+    size() const
+    { return size_type(end() - begin()); }
+    size_type
+    max_size() const
+    {
+      const size_type __isize =
+ __gnu_cxx::__numeric_traits<difference_type>::__max
+ - int(_S_word_bit) + 1;
+      const size_type __asize = _M_get_Bit_allocator().max_size();
+      return (__asize <= __isize / int(_S_word_bit)
+       ? __asize * int(_S_word_bit) : __isize);
+    }
+    size_type
+    capacity() const
+    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
+         - begin()); }
+    bool
+    empty() const
+    { return begin() == end(); }
+    reference
+    operator[](size_type __n)
+    {
+      return *iterator(this->_M_impl._M_start._M_p
+         + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+    const_reference
+    operator[](size_type __n) const
+    {
+      return *const_iterator(this->_M_impl._M_start._M_p
+        + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+  protected:
+    void
+    _M_range_check(size_type __n) const
+    {
+      if (__n >= this->size())
+        __throw_out_of_range(("vector<bool>::_M_range_check"));
+    }
+  public:
+    reference
+    at(size_type __n)
+    { _M_range_check(__n); return (*this)[__n]; }
+    const_reference
+    at(size_type __n) const
+    { _M_range_check(__n); return (*this)[__n]; }
+    void
+    reserve(size_type __n);
+    reference
+    front()
+    { return *begin(); }
+    const_reference
+    front() const
+    { return *begin(); }
+    reference
+    back()
+    { return *(end() - 1); }
+    const_reference
+    back() const
+    { return *(end() - 1); }
+    void
+    data() { }
+    void
+    push_back(bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(end(), __x);
+    }
+    void
+    swap(vector& __x)
+    {
+      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+      std::swap(this->_M_impl._M_end_of_storage,
+  __x._M_impl._M_end_of_storage);
+      std::__alloc_swap<typename _Base::_Bit_alloc_type>::
+ _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
+    }
+    static void
+    swap(reference __x, reference __y)
+    {
+      bool __tmp = __x;
+      __x = __y;
+      __y = __tmp;
+    }
+    iterator
+    insert(iterator __position, const bool& __x = bool())
+    {
+      const difference_type __n = __position - begin();
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
+   && __position == end())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(__position, __x);
+      return begin() + __n;
+    }
+    template<typename _InputIterator>
+      void
+      insert(iterator __position,
+      _InputIterator __first, _InputIterator __last)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_insert_dispatch(__position, __first, __last, _Integral());
+      }
+    void
+    insert(iterator __position, size_type __n, const bool& __x)
+    { _M_fill_insert(__position, __n, __x); }
+    void
+    pop_back()
+    { --this->_M_impl._M_finish; }
+    iterator
+    erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+    iterator
+    erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+    void
+    resize(size_type __new_size, bool __x = bool())
+    {
+      if (__new_size < size())
+        _M_erase_at_end(begin() + difference_type(__new_size));
+      else
+        insert(end(), __new_size - size(), __x);
+    }
+    void
+    flip()
+    {
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
+    __p != this->_M_impl._M_end_of_storage; ++__p)
+        *__p = ~*__p;
+    }
+    void
+    clear()
+    { _M_erase_at_end(begin()); }
+  protected:
+    iterator
+    _M_copy_aligned(const_iterator __first, const_iterator __last,
+      iterator __result)
+    {
+      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+      return std::copy(const_iterator(__last._M_p, 0), __last,
+         iterator(__q, 0));
+    }
+    void
+    _M_initialize(size_type __n)
+    {
+      _Bit_type* __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = (__q
+      + ((__n + int(_S_word_bit) - 1)
+         / int(_S_word_bit)));
+      this->_M_impl._M_start = iterator(__q, 0);
+      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+    }
+    template<typename _Integer>
+      void
+      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+      {
+ _M_initialize(static_cast<size_type>(__n));
+ std::fill(this->_M_impl._M_start._M_p,
+    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+      }
+    template<typename _InputIterator>
+      void
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+        __false_type)
+      { _M_initialize_range(__first, __last,
+       std::__iterator_category(__first)); }
+    template<typename _InputIterator>
+      void
+      _M_initialize_range(_InputIterator __first, _InputIterator __last,
+     std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   push_back(*__first);
+      }
+    template<typename _ForwardIterator>
+      void
+      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+     std::forward_iterator_tag)
+      {
+ const size_type __n = std::distance(__first, __last);
+ _M_initialize(__n);
+ std::copy(__first, __last, this->_M_impl._M_start);
+      }
+    template<typename _Integer>
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign(__n, __val); }
+    template<class _InputIterator>
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+    void
+    _M_fill_assign(size_t __n, bool __x)
+    {
+      if (__n > size())
+ {
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+   insert(end(), __n - size(), __x);
+ }
+      else
+ {
+   _M_erase_at_end(begin() + __n);
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+ }
+    }
+    template<typename _InputIterator>
+      void
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ iterator __cur = begin();
+ for (; __first != __last && __cur != end(); ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+    template<typename _ForwardIterator>
+      void
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+ if (__len < size())
+   _M_erase_at_end(std::copy(__first, __last, begin()));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, begin());
+     insert(end(), __mid, __last);
+   }
+      }
+    template<typename _Integer>
+      void
+      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+    __true_type)
+      { _M_fill_insert(__pos, __n, __x); }
+    template<typename _InputIterator>
+      void
+      _M_insert_dispatch(iterator __pos,
+    _InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_insert_range(__pos, __first, __last,
+   std::__iterator_category(__first)); }
+    void
+    _M_fill_insert(iterator __position, size_type __n, bool __x);
+    template<typename _InputIterator>
+      void
+      _M_insert_range(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+    template<typename _ForwardIterator>
+      void
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag);
+    void
+    _M_insert_aux(iterator __position, bool __x);
+    size_type
+    _M_check_len(size_type __n, const char* __s) const
+    {
+      if (max_size() - size() < __n)
+ __throw_length_error((__s));
+      const size_type __len = size() + std::max(size(), __n);
+      return (__len < size() || __len > max_size()) ? max_size() : __len;
+    }
+    void
+    _M_erase_at_end(iterator __pos)
+    { this->_M_impl._M_finish = __pos; }
+  };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp = _M_allocate_and_copy(__n,
+   (this->_M_impl._M_start),
+   (this->_M_impl._M_finish));
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __tmp;
+   this->_M_impl._M_finish = __tmp + __old_size;
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    insert(iterator __position, const value_type& __x)
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+   && __position == end())
+ {
+   this->_M_impl.construct(this->_M_impl._M_finish, __x);
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+     _M_insert_aux(__position, __x);
+ }
+      return iterator(this->_M_impl._M_start + __n);
+    }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    erase(iterator __position)
+    {
+      if (__position + 1 != end())
+ std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      this->_M_impl.destroy(this->_M_impl._M_finish);
+      return __position;
+    }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ {
+   if (__last != end())
+     std::copy(__last, end(), __first);
+   _M_erase_at_end(__first.base() + (end() - __last));
+ }
+      return __first;
+    }
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+ {
+   const size_type __xlen = __x.size();
+   if (__xlen > capacity())
+     {
+       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+         __x.end());
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __tmp;
+       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+     }
+   else if (size() >= __xlen)
+     {
+       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+       end(), _M_get_Tp_allocator());
+     }
+   else
+     {
+       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+   this->_M_impl._M_start);
+       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+       __x._M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+ }
+      return *this;
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+ {
+   vector __tmp(__n, __val, _M_get_Tp_allocator());
+   __tmp.swap(*this);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+     __n - size(), __val,
+     _M_get_Tp_allocator());
+   this->_M_impl._M_finish += __n - size();
+ }
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ pointer __cur(this->_M_impl._M_start);
+ for (; __first != __last && __cur != this->_M_impl._M_finish;
+      ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+ if (__len > capacity())
+   {
+     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     _M_deallocate(this->_M_impl._M_start,
+     this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_start);
+     this->_M_impl._M_start = __tmp;
+     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+   }
+ else if (size() >= __len)
+   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, this->_M_impl._M_start);
+     this->_M_impl._M_finish =
+       std::__uninitialized_copy_a(__mid, __last,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_insert_aux(iterator __position, const _Tp& __x)
+    {
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ {
+   this->_M_impl.construct(this->_M_impl._M_finish,
+      (*(this->_M_impl._M_finish - 1))
+             );
+   ++this->_M_impl._M_finish;
+   _Tp __x_copy = __x;
+   std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
+                                  ;
+   *__position = __x_copy;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector::_M_insert_aux");
+   const size_type __elems_before = __position - begin();
+   pointer __new_start(this->_M_allocate(__len));
+   pointer __new_finish(__new_start);
+   try
+     {
+       this->_M_impl.construct(__new_start + __elems_before,
+                               __x);
+       __new_finish = 0;
+       __new_finish =
+  std::__uninitialized_move_a(this->_M_impl._M_start,
+         __position.base(), __new_start,
+         _M_get_Tp_allocator());
+       ++__new_finish;
+       __new_finish =
+  std::__uninitialized_move_a(__position.base(),
+         this->_M_impl._M_finish,
+         __new_finish,
+         _M_get_Tp_allocator());
+     }
+          catch(...)
+     {
+       if (!__new_finish)
+  this->_M_impl.destroy(__new_start + __elems_before);
+       else
+  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+       _M_deallocate(__new_start, __len);
+       throw;
+     }
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __new_start;
+   this->_M_impl._M_finish = __new_finish;
+   this->_M_impl._M_end_of_storage = __new_start + __len;
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+       value_type __x_copy = __x;
+       const size_type __elems_after = end() - __position;
+       pointer __old_finish(this->_M_impl._M_finish);
+       if (__elems_after > __n)
+  {
+    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n;
+    std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
+                                        ;
+    std::fill(__position.base(), __position.base() + __n,
+       __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+      __n - __elems_after,
+      __x_copy,
+      _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n - __elems_after;
+    std::__uninitialized_move_a(__position.base(), __old_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __elems_after;
+    std::fill(__position.base(), __old_finish, __x_copy);
+  }
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_fill_insert");
+       const size_type __elems_before = __position - begin();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+    std::__uninitialized_fill_n_a(__new_start + __elems_before,
+      __n, __x,
+      _M_get_Tp_allocator());
+    __new_finish = 0;
+    __new_finish =
+      std::__uninitialized_move_a(this->_M_impl._M_start,
+      __position.base(),
+      __new_start,
+      _M_get_Tp_allocator());
+    __new_finish += __n;
+    __new_finish =
+      std::__uninitialized_move_a(__position.base(),
+      this->_M_impl._M_finish,
+      __new_finish,
+      _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (!__new_finish)
+      std::_Destroy(__new_start + __elems_before,
+      __new_start + __elems_before + __n,
+      _M_get_Tp_allocator());
+    else
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     const size_type __n = std::distance(__first, __last);
+     if (size_type(this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_finish) >= __n)
+       {
+  const size_type __elems_after = end() - __position;
+  pointer __old_finish(this->_M_impl._M_finish);
+  if (__elems_after > __n)
+    {
+      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+      this->_M_impl._M_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n;
+      std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
+                                          ;
+      std::copy(__first, __last, __position);
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, __elems_after);
+      std::__uninitialized_copy_a(__mid, __last,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n - __elems_after;
+      std::__uninitialized_move_a(__position.base(),
+      __old_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __elems_after;
+      std::copy(__first, __mid, __position);
+    }
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector::_M_range_insert");
+  pointer __new_start(this->_M_allocate(__len));
+  pointer __new_finish(__new_start);
+  try
+    {
+      __new_finish =
+        std::__uninitialized_move_a(this->_M_impl._M_start,
+        __position.base(),
+        __new_start,
+        _M_get_Tp_allocator());
+      __new_finish =
+        std::__uninitialized_copy_a(__first, __last,
+        __new_finish,
+        _M_get_Tp_allocator());
+      __new_finish =
+        std::__uninitialized_move_a(__position.base(),
+        this->_M_impl._M_finish,
+        __new_finish,
+        _M_get_Tp_allocator());
+    }
+  catch(...)
+    {
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+      _M_deallocate(__new_start, __len);
+      throw;
+    }
+  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  _M_deallocate(this->_M_impl._M_start,
+         this->_M_impl._M_end_of_storage
+         - this->_M_impl._M_start);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+  this->_M_impl._M_end_of_storage = __new_start + __len;
+       }
+   }
+      }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   _Bit_type* __q = this->_M_allocate(__n);
+   this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
+          iterator(__q, 0));
+   this->_M_deallocate();
+   this->_M_impl._M_start = iterator(__q, 0);
+   this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
+          / int(_S_word_bit));
+ }
+    }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+ return;
+      if (capacity() - size() >= __n)
+ {
+   std::copy_backward(__position, end(),
+        this->_M_impl._M_finish + difference_type(__n));
+   std::fill(__position, __position + difference_type(__n), __x);
+   this->_M_impl._M_finish += difference_type(__n);
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(__n, "vector<bool>::_M_fill_insert");
+   _Bit_type * __q = this->_M_allocate(__len);
+   iterator __i = _M_copy_aligned(begin(), __position,
+      iterator(__q, 0));
+   std::fill(__i, __i + difference_type(__n), __x);
+   this->_M_impl._M_finish = std::copy(__position, end(),
+           __i + difference_type(__n));
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = (__q + ((__len
+           + int(_S_word_bit) - 1)
+          / int(_S_word_bit)));
+   this->_M_impl._M_start = iterator(__q, 0);
+ }
+    }
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     size_type __n = std::distance(__first, __last);
+     if (capacity() - size() >= __n)
+       {
+  std::copy_backward(__position, end(),
+       this->_M_impl._M_finish
+       + difference_type(__n));
+  std::copy(__first, __last, __position);
+  this->_M_impl._M_finish += difference_type(__n);
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector<bool>::_M_insert_range");
+  _Bit_type * __q = this->_M_allocate(__len);
+  iterator __i = _M_copy_aligned(begin(), __position,
+            iterator(__q, 0));
+  __i = std::copy(__first, __last, __i);
+  this->_M_impl._M_finish = std::copy(__position, end(), __i);
+  this->_M_deallocate();
+  this->_M_impl._M_end_of_storage = (__q
+         + ((__len
+             + int(_S_word_bit) - 1)
+            / int(_S_word_bit)));
+  this->_M_impl._M_start = iterator(__q, 0);
+       }
+   }
+      }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+ {
+   std::copy_backward(__position, this->_M_impl._M_finish,
+        this->_M_impl._M_finish + 1);
+   *__position = __x;
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+   _Bit_type * __q = this->_M_allocate(__len);
+   iterator __i = _M_copy_aligned(begin(), __position,
+      iterator(__q, 0));
+   *__i++ = __x;
+   this->_M_impl._M_finish = std::copy(__position, end(), __i);
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = (__q + ((__len
+           + int(_S_word_bit) - 1)
+          / int(_S_word_bit)));
+   this->_M_impl._M_start = iterator(__q, 0);
+ }
+    }
+}
+class Document;
+namespace DotParser {
+    bool parse(const std::string& str, Document* graphDoc);
+    bool parseIntegers(const std::string& str, std::vector<int>& v);
+    void setStrict();
+    void undirectedDataStructure();
+    void directedDataStructure();
+    void dataStructureId(const std::string& str);
+    void attributeId(const std::string& str);
+    void subDataStructureId(const std::string& str);
+    void valid(const std::string& str);
+    void insertAttributeIntoAttributeList();
+    void createAttributeList();
+    void removeAttributeList();
+    void createSubDataStructure();
+    void createData(const std::string& str);
+    void setDataStructureAttributes();
+    void setSubDataStructureAttributes(char const* first, char const* last);
+    void setDataAttributes();
+    void applyAttributeList();
+    void checkEdgeOperator(const std::string& str);
+    void edgebound(const std::string& str);
+    void createPointers();
+    void leaveSubDataStructure();
+}
+typedef long int ptrdiff_t;
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  namespace rel_ops
+  {
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+  }
+}
+extern "C" {
+union wait
+  {
+    int w_status;
+    struct
+      {
+ unsigned int:16;
+ unsigned int __w_retcode:8;
+ unsigned int __w_coredump:1;
+ unsigned int __w_termsig:7;
+      } __wait_terminated;
+    struct
+      {
+ unsigned int:16;
+ unsigned int __w_stopsig:8;
+ unsigned int __w_stopval:8;
+      } __wait_stopped;
+  };
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));
+extern double atof (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int atoi (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long int atol (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+__extension__ extern long long int atoll (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern double strtod (__const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern float strtof (__const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long double strtold (__const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long int strtol (__const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern unsigned long int strtoul (__const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern long long int strtoq (__const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern unsigned long long int strtouq (__const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern long long int strtoll (__const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern unsigned long long int strtoull (__const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern long int strtol_l (__const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+extern unsigned long int strtoul_l (__const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern long long int strtoll_l (__const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+__extension__
+extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+extern double strtod_l (__const char *__restrict __nptr,
+   char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+extern float strtof_l (__const char *__restrict __nptr,
+         char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+extern long double strtold_l (__const char *__restrict __nptr,
+         char **__restrict __endptr,
+         __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+extern __inline __attribute__ ((__gnu_inline__)) double
+__attribute__ ((__leaf__)) atof (__const char *__nptr) throw ()
+{
+  return strtod (__nptr, (char **) __null);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) atoi (__const char *__nptr) throw ()
+{
+  return (int) strtol (__nptr, (char **) __null, 10);
+}
+extern __inline __attribute__ ((__gnu_inline__)) long int
+__attribute__ ((__leaf__)) atol (__const char *__nptr) throw ()
+{
+  return strtol (__nptr, (char **) __null, 10);
+}
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
+__attribute__ ((__leaf__)) atoll (__const char *__nptr) throw ()
+{
+  return strtoll (__nptr, (char **) __null, 10);
+}
+extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));
+extern long int a64l (__const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern "C" {
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+typedef __loff_t loff_t;
+typedef __ino_t ino_t;
+typedef __ino64_t ino64_t;
+typedef __dev_t dev_t;
+typedef __mode_t mode_t;
+typedef __nlink_t nlink_t;
+typedef __id_t id_t;
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+typedef __key_t key_t;
+typedef __suseconds_t suseconds_t;
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+typedef int int8_t __attribute__ ((__mode__ (__QI__)));
+typedef int int16_t __attribute__ ((__mode__ (__HI__)));
+typedef int int32_t __attribute__ ((__mode__ (__SI__)));
+typedef int int64_t __attribute__ ((__mode__ (__DI__)));
+typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
+typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+typedef int __sig_atomic_t;
+typedef struct
+  {
+    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+  } __sigset_t;
+typedef __sigset_t sigset_t;
+typedef long int __fd_mask;
+typedef struct
+  {
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+  } fd_set;
+typedef __fd_mask fd_mask;
+extern "C" {
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+extern long int __fdelt_chk (long int __d);
+extern long int __fdelt_warn (long int __d)
+  __attribute__((__warning__ ("bit outside of fd_set selected")));
+}
+extern "C" {
+__extension__
+extern unsigned int gnu_dev_major (unsigned long long int __dev)
+     throw () __attribute__ ((__const__));
+__extension__
+extern unsigned int gnu_dev_minor (unsigned long long int __dev)
+     throw () __attribute__ ((__const__));
+__extension__
+extern unsigned long long int gnu_dev_makedev (unsigned int __major,
+            unsigned int __minor)
+     throw () __attribute__ ((__const__));
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
+__attribute__ ((__leaf__)) gnu_dev_major (unsigned long long int __dev) throw ()
+{
+  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
+}
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
+__attribute__ ((__leaf__)) gnu_dev_minor (unsigned long long int __dev) throw ()
+{
+  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
+}
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int
+__attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
+{
+  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
+   | (((unsigned long long int) (__minor & ~0xff)) << 12)
+   | (((unsigned long long int) (__major & ~0xfff)) << 32));
+}
+}
+typedef __blksize_t blksize_t;
+typedef __blkcnt_t blkcnt_t;
+typedef __fsblkcnt_t fsblkcnt_t;
+typedef __fsfilcnt_t fsfilcnt_t;
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+}
+extern long int random (void) throw ();
+extern void srandom (unsigned int __seed) throw ();
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int rand (void) throw ();
+extern void srand (unsigned int __seed) throw ();
+extern int rand_r (unsigned int *__seed) throw ();
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    unsigned long long int __a;
+  };
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+extern void free (void *__ptr) throw ();
+extern void cfree (void *__ptr) throw ();
+extern "C" {
+extern void *alloca (size_t __size) throw ();
+}
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *__secure_getenv (__const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+extern int setenv (__const char *__name, __const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int unsetenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+extern int clearenv (void) throw ();
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int system (__const char *__command) __attribute__ ((__warn_unused_result__));
+extern char *canonicalize_file_name (__const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *realpath (__const char *__restrict __name,
+         char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));
+typedef int (*__compar_fn_t) (__const void *, __const void *);
+typedef __compar_fn_t comparison_fn_t;
+typedef int (*__compar_d_fn_t) (__const void *, __const void *, void *);
+extern void *bsearch (__const void *__key, __const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+extern int abs (int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int mblen (__const char *__s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
+extern int mbtowc (wchar_t *__restrict __pwc,
+     __const char *__restrict __s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
+extern int wctomb (char *__s, wchar_t __wchar) throw () __attribute__ ((__warn_unused_result__));
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   __const char *__restrict __s, size_t __n) throw ();
+extern size_t wcstombs (char *__restrict __s,
+   __const wchar_t *__restrict __pwcs, size_t __n)
+     throw ();
+extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int getsubopt (char **__restrict __optionp,
+        char *__const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
+extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));
+extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
+extern int grantpt (int __fd) throw ();
+extern int unlockpt (int __fd) throw ();
+extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int getpt (void);
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern char *__realpath_chk (__const char *__restrict __name,
+        char *__restrict __resolved,
+        size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
+extern char *__realpath_alias (__const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")
+                                                 __attribute__ ((__warn_unused_result__));
+extern char *__realpath_chk_warn (__const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")
+                                                __attribute__ ((__warn_unused_result__))
+     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
+                                      ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+__attribute__ ((__leaf__)) realpath (__const char *__restrict __name, char *__restrict __resolved) throw ()
+{
+  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
+    {
+      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
+    }
+  return __realpath_alias (__name, __resolved);
+}
+extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
+       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
+extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")
+     __attribute__ ((__nonnull__ (2)));
+extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")
+     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
+                   ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __ptsname_r_alias (__fd, __buf, __buflen);
+}
+extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
+  throw () __attribute__ ((__warn_unused_result__));
+extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
+              __attribute__ ((__warn_unused_result__));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) int
+__attribute__ ((__leaf__)) wctomb (char *__s, wchar_t __wchar) throw ()
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
+    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
+  return __wctomb_alias (__s, __wchar);
+}
+extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
+         __const char *__restrict __src,
+         size_t __len, size_t __dstlen) throw ();
+extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")
+                                  ;
+extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")
+     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) mbstowcs (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbstowcs_chk (__dst, __src, __len,
+          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbstowcs_chk_warn (__dst, __src, __len,
+         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbstowcs_alias (__dst, __src, __len);
+}
+extern size_t __wcstombs_chk (char *__restrict __dst,
+         __const wchar_t *__restrict __src,
+         size_t __len, size_t __dstlen) throw ();
+extern size_t __wcstombs_alias (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")
+                                  ;
+extern size_t __wcstombs_chk_warn (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")
+     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+__attribute__ ((__leaf__)) wcstombs (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw ()
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcstombs_alias (__dst, __src, __len);
+}
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  using ::div_t;
+  using ::ldiv_t;
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+  using ::qsort;
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+  using ::wcstombs;
+  using ::wctomb;
+  inline long
+  abs(long __i) { return labs(__i); }
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  using ::lldiv_t;
+  using ::_Exit;
+  inline long long
+  abs(long long __x) { return __x >= 0 ? __x : -__x; }
+  using ::llabs;
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+  using ::lldiv;
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+  using ::strtof;
+  using ::strtold;
+}
+namespace std
+{
+  using ::__gnu_cxx::lldiv_t;
+  using ::__gnu_cxx::_Exit;
+  using ::__gnu_cxx::abs;
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _FIter, typename _Tp>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _IIter, typename _OIter>
+    _OIter
+    copy(_IIter, _IIter, _OIter);
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _FIter, typename _Tp>
+    void
+    fill(_FIter, _FIter, const _Tp&);
+  template<typename _OIter, typename _Size, typename _Tp>
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+  template<typename _BIter>
+    void
+    inplace_merge(_BIter, _BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    void
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+  template<typename _FIter1, typename _FIter2>
+    void
+    iter_swap(_FIter1, _FIter2);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _RAIter>
+    void
+    make_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    make_heap(_RAIter, _RAIter, _Compare);
+  template<typename _Tp>
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+  template<typename _Tp>
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+  template<typename _BIter>
+    bool
+    next_permutation(_BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    bool
+    next_permutation(_BIter, _BIter, _Compare);
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    void
+    pop_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    pop_heap(_RAIter, _RAIter, _Compare);
+  template<typename _BIter>
+    bool
+    prev_permutation(_BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    bool
+    prev_permutation(_BIter, _BIter, _Compare);
+  template<typename _RAIter>
+    void
+    push_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    push_heap(_RAIter, _RAIter, _Compare);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    remove(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    remove_if(_FIter, _FIter, _Predicate);
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+  template<typename _BIter>
+    void
+    reverse(_BIter, _BIter);
+  template<typename _BIter, typename _OIter>
+    _OIter
+    reverse_copy(_BIter, _BIter, _OIter);
+  template<typename _FIter>
+    void
+    rotate(_FIter, _FIter, _FIter);
+  template<typename _FIter, typename _OIter>
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+  template<typename _RAIter>
+    void
+    sort_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+  template<typename _Tp>
+    void
+    swap(_Tp&, _Tp&);
+  template<typename _Tp, size_t _Nm>
+    void
+    swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);
+  template<typename _FIter1, typename _FIter2>
+    _FIter2
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+  template<typename _FIter>
+    _FIter
+    unique(_FIter, _FIter);
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    unique(_FIter, _FIter, _BinaryPredicate);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter);
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+  template<typename _IIter, typename _Funct>
+    _Funct
+    for_each(_IIter, _IIter, _Funct);
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator);
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+  template<typename _FIter>
+    _FIter
+    max_element(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _FIter>
+    _FIter
+    min_element(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    partition(_BIter, _BIter, _Predicate);
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Generator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+     _Generator&);
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+  template<typename _FIter, typename _Size, typename _Tp,
+    typename _BinaryPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+        _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _BinaryOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _RandomAccessIterator, typename _Distance>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__first[__parent] < __first[__child])
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+      _Compare __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__comp(__first[__parent], __first[__child]))
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    { return std::__is_heap_until(__first, __n) == __n; }
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    { return std::__is_heap_until(__first, __n, __comp) == __n; }
+  template<typename _RandomAccessIterator>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
+    void
+    __push_heap(_RandomAccessIterator __first,
+  _Distance __holeIndex, _Distance __topIndex, _Tp __value)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
+ {
+   *(__first + __holeIndex) = (*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = (__value);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+      ;
+      ;
+      _ValueType __value = (*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), (__value));
+    }
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+    typename _Compare>
+    void
+    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+  _Distance __topIndex, _Tp __value, _Compare __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex
+      && __comp(*(__first + __parent), __value))
+ {
+   *(__first + __holeIndex) = (*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = (__value);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+      ;
+      ;
+      _ValueType __value = (*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), (__value), __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
+     __secondChild--;
+   *(__first + __holeIndex) = (*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
+                                  ;
+   __holeIndex = __secondChild - 1;
+ }
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         (__value));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      _ValueType __value = (*__result);
+      *__result = (*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    (__value));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      --__last;
+      std::__pop_heap(__first, __last, __last);
+    }
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Tp, typename _Compare>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (__comp(*(__first + __secondChild),
+       *(__first + (__secondChild - 1))))
+     __secondChild--;
+   *(__first + __holeIndex) = (*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
+                                  ;
+   __holeIndex = __secondChild - 1;
+ }
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         (__value), __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      _ValueType __value = (*__result);
+      *__result = (*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    (__value), __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      ;
+      ;
+      --__last;
+      std::__pop_heap(__first, __last, __last, __comp);
+    }
+  template<typename _RandomAccessIterator>
+    void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+      ;
+      if (__last - __first < 2)
+ return;
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = (*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, (__value));
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+      ;
+      if (__last - __first < 2)
+ return;
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = (*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, (__value),
+        __comp);
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+  template<typename _RandomAccessIterator>
+    void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      ;
+      ;
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      ;
+      ;
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len)
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p, std::nothrow); }
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+    public:
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef pointer iterator;
+      typedef ptrdiff_t size_type;
+    protected:
+      size_type _M_original_len;
+      size_type _M_len;
+      pointer _M_buffer;
+    public:
+      size_type
+      size() const
+      { return _M_len; }
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+      iterator
+      begin()
+      { return _M_buffer; }
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::return_temporary_buffer(_M_buffer);
+      }
+    private:
+      _Temporary_buffer(const _Temporary_buffer&);
+      void
+      operator=(const _Temporary_buffer&);
+    };
+  template<bool>
+    struct __uninitialized_construct_buf_dispatch
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __ucr(_ForwardIterator __first, _ForwardIterator __last,
+       _Tp& __value)
+        {
+   if(__first == __last)
+     return;
+   _ForwardIterator __cur = __first;
+   try
+     {
+       std::_Construct(std::__addressof(*__first),
+         (__value));
+       _ForwardIterator __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(std::__addressof(*__cur),
+    (*__prev));
+       __value = (*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { }
+    };
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_construct_buf(_ForwardIterator __first,
+      _ForwardIterator __last,
+      _Tp& __value)
+    {
+      typedef typename std::iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __value);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _M_original_len(std::distance(__first, __last)),
+      _M_len(0), _M_buffer(0)
+    {
+      try
+ {
+   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
+         value_type>(_M_original_len));
+   _M_buffer = __p.first;
+   _M_len = __p.second;
+   if(_M_buffer)
+     std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
+            *__first);
+ }
+      catch(...)
+ {
+   std::return_temporary_buffer(_M_buffer);
+   _M_buffer = 0;
+   _M_len = 0;
+   throw;
+ }
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Iterator>
+    void
+    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
+    {
+      if (*__a < *__b)
+ {
+   if (*__b < *__c)
+     std::iter_swap(__a, __b);
+   else if (*__a < *__c)
+     std::iter_swap(__a, __c);
+ }
+      else if (*__a < *__c)
+ return;
+      else if (*__b < *__c)
+ std::iter_swap(__a, __c);
+      else
+ std::iter_swap(__a, __b);
+    }
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
+   _Compare __comp)
+    {
+      if (__comp(*__a, *__b))
+ {
+   if (__comp(*__b, *__c))
+     std::iter_swap(__a, __b);
+   else if (__comp(*__a, *__c))
+     std::iter_swap(__a, __c);
+ }
+      else if (__comp(*__a, *__c))
+ return;
+      else if (__comp(*__b, *__c))
+ std::iter_swap(__a, __c);
+      else
+ std::iter_swap(__a, __b);
+    }
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    __find(_InputIterator __first, _InputIterator __last,
+    const _Tp& __val, input_iterator_tag)
+    {
+      while (__first != __last && !(*__first == __val))
+ ++__first;
+      return __first;
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !bool(__pred(*__first)))
+ ++__first;
+      return __first;
+    }
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    const _Tp& __val, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (*__first == __val)
+     return __first;
+   ++__first;
+   if (*__first == __val)
+     return __first;
+   ++__first;
+   if (*__first == __val)
+     return __first;
+   ++__first;
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ }
+      switch (__last - __first)
+ {
+ case 3:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 2:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 1:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ }
+      switch (__last - __first)
+ {
+ case 3:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 2:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 1:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count, const _Tp& __val,
+        std::forward_iterator_tag)
+    {
+      __first = std::find(__first, __last, __val);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && *__i == __val)
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::find(++__i, __last, __val);
+ }
+      return __last;
+    }
+  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
+    _RandomAccessIter
+    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+        _Integer __count, const _Tp& __val,
+        std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+      _DistanceType __tailSize = __last - __first;
+      const _DistanceType __pattSize = __count;
+      if (__tailSize < __pattSize)
+        return __last;
+      const _DistanceType __skipOffset = __pattSize - 1;
+      _RandomAccessIter __lookAhead = __first + __skipOffset;
+      __tailSize -= __pattSize;
+      while (1)
+ {
+   while (!(*__lookAhead == __val))
+     {
+       if (__tailSize < __pattSize)
+  return __last;
+       __lookAhead += __pattSize;
+       __tailSize -= __pattSize;
+     }
+   _DistanceType __remainder = __skipOffset;
+   for (_RandomAccessIter __backTrack = __lookAhead - 1;
+        *__backTrack == __val; --__backTrack)
+     {
+       if (--__remainder == 0)
+  return (__lookAhead - __skipOffset);
+     }
+   if (__remainder > __tailSize)
+     return __last;
+   __lookAhead += __remainder;
+   __tailSize -= __remainder;
+ }
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count, const _Tp& __val,
+        _BinaryPredicate __binary_pred, std::forward_iterator_tag)
+    {
+      while (__first != __last && !bool(__binary_pred(*__first, __val)))
+        ++__first;
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = ++__i;
+   while (__first != __last
+   && !bool(__binary_pred(*__first, __val)))
+     ++__first;
+ }
+      return __last;
+    }
+  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
+    typename _BinaryPredicate>
+    _RandomAccessIter
+    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+        _Integer __count, const _Tp& __val,
+        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+      _DistanceType __tailSize = __last - __first;
+      const _DistanceType __pattSize = __count;
+      if (__tailSize < __pattSize)
+        return __last;
+      const _DistanceType __skipOffset = __pattSize - 1;
+      _RandomAccessIter __lookAhead = __first + __skipOffset;
+      __tailSize -= __pattSize;
+      while (1)
+ {
+   while (!bool(__binary_pred(*__lookAhead, __val)))
+     {
+       if (__tailSize < __pattSize)
+  return __last;
+       __lookAhead += __pattSize;
+       __tailSize -= __pattSize;
+     }
+   _DistanceType __remainder = __skipOffset;
+   for (_RandomAccessIter __backTrack = __lookAhead - 1;
+        __binary_pred(*__backTrack, __val); --__backTrack)
+     {
+       if (--__remainder == 0)
+  return (__lookAhead - __skipOffset);
+     }
+   if (__remainder > __tailSize)
+     return __last;
+   __lookAhead += __remainder;
+   __tailSize -= __remainder;
+ }
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag)
+    {
+      if (__first2 == __last2)
+ return __last1;
+      else
+ {
+   _ForwardIterator1 __result = __last1;
+   while (1)
+     {
+       _ForwardIterator1 __new_result
+  = std::search(__first1, __last1, __first2, __last2);
+       if (__new_result == __last1)
+  return __result;
+       else
+  {
+    __result = __new_result;
+    __first1 = __new_result;
+    ++__first1;
+  }
+     }
+ }
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+ return __last1;
+      else
+ {
+   _ForwardIterator1 __result = __last1;
+   while (1)
+     {
+       _ForwardIterator1 __new_result
+  = std::search(__first1, __last1, __first2,
+      __last2, __comp);
+       if (__new_result == __last1)
+  return __result;
+       else
+  {
+    __result = __new_result;
+    __first1 = __new_result;
+    ++__first1;
+  }
+     }
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag)
+    {
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
+             __rlast1,
+             _RevIterator2(__last2),
+             __rlast2);
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BinaryPredicate>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
+         _RevIterator2(__last2), __rlast2,
+         __comp);
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      ;
+      ;
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2));
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+      ;
+      ;
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __comp);
+    }
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ if (!(*__first == __value))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ if (!bool(__pred(*__first)))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+      ;
+      __first = std::find(__first, __last, __value);
+      if(__first == __last)
+        return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for(; __first != __last; ++__first)
+        if(!(*__first == __value))
+          {
+            *__result = (*__first);
+            ++__result;
+          }
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+      ;
+      __first = std::find_if(__first, __last, __pred);
+      if(__first == __last)
+        return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for(; __first != __last; ++__first)
+        if(!bool(__pred(*__first)))
+          {
+            *__result = (*__first);
+            ++__result;
+          }
+      return __result;
+    }
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      ;
+      __first = std::adjacent_find(__first, __last);
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!(*__dest == *__first))
+   *++__dest = (*__first);
+      return ++__dest;
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+           _BinaryPredicate __binary_pred)
+    {
+      ;
+      __first = std::adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!bool(__binary_pred(*__dest, *__first)))
+   *++__dest = (*__first);
+      return ++__dest;
+    }
+  template<typename _ForwardIterator, typename _OutputIterator>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result,
+    forward_iterator_tag, output_iterator_tag)
+    {
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!(*__first == *__next))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result,
+    input_iterator_tag, output_iterator_tag)
+    {
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ if (!(__value == *__first))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _ForwardIterator>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result,
+    input_iterator_tag, forward_iterator_tag)
+    {
+      *__result = *__first;
+      while (++__first != __last)
+ if (!(*__result == *__first))
+   *++__result = *__first;
+      return ++__result;
+    }
+  template<typename _ForwardIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    forward_iterator_tag, output_iterator_tag)
+    {
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!bool(__binary_pred(*__first, *__next)))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, output_iterator_tag)
+    {
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ if (!bool(__binary_pred(__value, *__first)))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, forward_iterator_tag)
+    {
+      *__result = *__first;
+      while (++__first != __last)
+ if (!bool(__binary_pred(*__result, *__first)))
+   *++__result = *__first;
+      return ++__result;
+    }
+  template<typename _BidirectionalIterator>
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      while (true)
+ if (__first == __last || __first == --__last)
+   return;
+ else
+   {
+     std::iter_swap(__first, __last);
+     ++__first;
+   }
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       random_access_iterator_tag)
+    {
+      if (__first == __last)
+ return;
+      --__last;
+      while (__first < __last)
+ {
+   std::iter_swap(__first, __last);
+   ++__first;
+   --__last;
+ }
+    }
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+      ;
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+  template<typename _EuclideanRingElement>
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+  template<typename _ForwardIterator>
+    void
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle || __last == __middle)
+ return;
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+      __first2 = __middle;
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+    }
+  template<typename _BidirectionalIterator>
+    void
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      if (__first == __middle || __last == __middle)
+ return;
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+      if (__first == __middle)
+ std::__reverse(__middle, __last, bidirectional_iterator_tag());
+      else
+ std::__reverse(__first, __middle, bidirectional_iterator_tag());
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+      if (__first == __middle || __last == __middle)
+ return;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return;
+ }
+      _RandomAccessIterator __p = __first;
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = (*__p);
+    std::copy(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = (__t);
+    return;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = (*(__p + __n - 1));
+    std::copy_backward(__p, __p + __n - 1, __p + __n);
+    *__p = (__t);
+    return;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return;
+       std::swap(__n, __k);
+     }
+ }
+    }
+  template<typename _ForwardIterator>
+    inline void
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+      ;
+      ;
+      typedef typename iterator_traits<_ForwardIterator>::iterator_category
+ _IterType;
+      std::__rotate(__first, __middle, __last, _IterType());
+    }
+  template<typename _ForwardIterator, typename _OutputIterator>
+    _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+                _ForwardIterator __last, _OutputIterator __result)
+    {
+      ;
+      ;
+      return std::copy(__first, __middle,
+                       std::copy(__middle, __last, __result));
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+ return __first;
+      while (__pred(*__first))
+ if (++__first == __last)
+   return __first;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+ if (__pred(*__next))
+   {
+     std::iter_swap(__first, __next);
+     ++__first;
+   }
+      return __first;
+    }
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+  _Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+ {
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (__pred(*__first))
+       ++__first;
+     else
+       break;
+   --__last;
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (!bool(__pred(*__last)))
+       --__last;
+     else
+       break;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
+    _ForwardIterator
+    __inplace_stable_partition(_ForwardIterator __first,
+          _ForwardIterator __last,
+          _Predicate __pred, _Distance __len)
+    {
+      if (__len == 1)
+ return __pred(*__first) ? __last : __first;
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
+         __middle,
+         __pred,
+         __len / 2);
+      _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
+              __pred,
+              __len
+              - __len / 2);
+      std::rotate(__begin, __middle, __end);
+      std::advance(__begin, std::distance(__middle, __end));
+      return __begin;
+    }
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+    typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred, _Distance __len,
+    _Pointer __buffer,
+    _Distance __buffer_size)
+    {
+      if (__len <= __buffer_size)
+ {
+   _ForwardIterator __result1 = __first;
+   _Pointer __result2 = __buffer;
+   for (; __first != __last; ++__first)
+     if (__pred(*__first))
+       {
+  *__result1 = (*__first);
+  ++__result1;
+       }
+     else
+       {
+  *__result2 = (*__first);
+  ++__result2;
+       }
+   std::copy(__buffer, __result2, __result1);
+   return __result1;
+ }
+      else
+ {
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __len / 2);
+   _ForwardIterator __begin =
+     std::__stable_partition_adaptive(__first, __middle, __pred,
+          __len / 2, __buffer,
+          __buffer_size);
+   _ForwardIterator __end =
+     std::__stable_partition_adaptive(__middle, __last, __pred,
+          __len - __len / 2,
+          __buffer, __buffer_size);
+   std::rotate(__begin, __middle, __end);
+   std::advance(__begin, std::distance(__middle, __end));
+   return __begin;
+ }
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+      ;
+      if (__first == __last)
+ return __first;
+      else
+ {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+   typedef typename iterator_traits<_ForwardIterator>::difference_type
+     _DistanceType;
+   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
+        __last);
+ if (__buf.size() > 0)
+   return
+     std::__stable_partition_adaptive(__first, __last, __pred,
+       _DistanceType(__buf.requested_size()),
+       __buf.begin(),
+       _DistanceType(__buf.size()));
+ else
+   return
+     std::__inplace_stable_partition(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()));
+ }
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last)
+    {
+      std::make_heap(__first, __middle);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (*__i < *__first)
+   std::__pop_heap(__first, __middle, __i);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (__comp(*__i, *__first))
+   std::__pop_heap(__first, __middle, __i, __comp);
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      ;
+      ;
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while(__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+      std::make_heap(__result_first, __result_real_last);
+      while (__first != __last)
+ {
+   if (*__first < *__result_first)
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first));
+   ++__first;
+ }
+      std::sort_heap(__result_first, __result_real_last);
+      return __result_real_last;
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      ;
+      ;
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while(__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+      std::make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(*__first, *__result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first),
+          __comp);
+   ++__first;
+ }
+      std::sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = (*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__val < *__next)
+ {
+   *__last = (*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = (__val);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+         _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = (*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, *__next))
+ {
+   *__last = (*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = (__val);
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last)
+    {
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (*__i < *__first)
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = (*__i);
+       std::copy_backward(__first, __i, __i + 1);
+       *__first = (__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (__comp(*__i, *__first))
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = (*__i);
+       std::copy_backward(__first, __i, __i + 1);
+       *__first = (__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i, __comp);
+ }
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i, __comp);
+    }
+  enum { _S_threshold = 16 };
+  template<typename _RandomAccessIterator>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold));
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
+ }
+      else
+ std::__insertion_sort(__first, __last);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+       __comp);
+ }
+      else
+ std::__insertion_sort(__first, __last, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, const _Tp& __pivot)
+    {
+      while (true)
+ {
+   while (*__first < __pivot)
+     ++__first;
+   --__last;
+   while (__pivot < *__last)
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     const _Tp& __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(*__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, *__last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+  template<typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_first(__first, __mid, (__last - 1));
+      return std::__unguarded_partition(__first + 1, __last, *__first);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_first(__first, __mid, (__last - 1), __comp);
+      return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Size>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::partial_sort(__first, __last, __last);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last);
+   std::__introsort_loop(__cut, __last, __depth_limit);
+   __last = __cut;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::partial_sort(__first, __last, __last, __comp);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+   __last = __cut;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Size>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last);
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last);
+    }
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+                    ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(*__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__val < *__middle)
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+                    ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__val, *__middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      ;
+      ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (*__middle < __val)
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__val < *__middle)
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left = std::lower_bound(__first, __middle,
+        __val);
+       std::advance(__first, __len);
+       _ForwardIterator __right = std::upper_bound(++__middle, __first,
+         __val);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+                    ;
+                    ;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(*__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp(__val, *__middle))
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left = std::lower_bound(__first, __middle,
+        __val, __comp);
+       std::advance(__first, __len);
+       _ForwardIterator __right = std::upper_bound(++__middle, __first,
+         __val, __comp);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
+      return __i != __last && !(__val < *__i);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+                    ;
+                    ;
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first2 < *__first1)
+     {
+       *__result = (*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = (*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      if (__first1 != __last1)
+ std::copy(__first1, __last1, __result);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first2, *__first1))
+     {
+       *__result = (*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = (*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      if (__first1 != __last1)
+ std::copy(__first1, __last1, __result);
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result)
+    {
+      if (__first1 == __last1)
+ {
+   std::copy_backward(__first2, __last2, __result);
+   return;
+ }
+      else if (__first2 == __last2)
+ return;
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (*__last2 < *__last1)
+     {
+       *--__result = (*__last1);
+       if (__first1 == __last1)
+  {
+    std::copy_backward(__first2, ++__last2, __result);
+    return;
+  }
+       --__last1;
+     }
+   else
+     {
+       *--__result = (*__last2);
+       if (__first2 == __last2)
+  return;
+       --__last2;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3, typename _Compare>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result,
+       _Compare __comp)
+    {
+      if (__first1 == __last1)
+ {
+   std::copy_backward(__first2, __last2, __result);
+   return;
+ }
+      else if (__first2 == __last2)
+ return;
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (__comp(*__last2, *__last1))
+     {
+       *--__result = (*__last1);
+       if (__first1 == __last1)
+  {
+    std::copy_backward(__first2, ++__last2, __result);
+    return;
+  }
+       --__last1;
+     }
+   else
+     {
+       *--__result = (*__last2);
+       if (__first2 == __last2)
+  return;
+       --__last2;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+        _BidirectionalIterator1 __middle,
+        _BidirectionalIterator1 __last,
+        _Distance __len1, _Distance __len2,
+        _BidirectionalIterator2 __buffer,
+        _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+ {
+   if (__len2)
+     {
+       __buffer_end = std::copy(__middle, __last, __buffer);
+       std::copy_backward(__first, __middle, __last);
+       return std::copy(__buffer, __buffer_end, __first);
+     }
+   else
+     return __first;
+ }
+      else if (__len1 <= __buffer_size)
+ {
+   if (__len1)
+     {
+       __buffer_end = std::copy(__first, __middle, __buffer);
+       std::copy(__middle, __last, __first);
+       return std::copy_backward(__buffer, __buffer_end, __last);
+     }
+   else
+     return __last;
+ }
+      else
+ {
+   std::rotate(__first, __middle, __last);
+   std::advance(__first, std::distance(__middle, __last));
+   return __first;
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+         __first);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
+   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+           __buffer_end, __last);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut = std::lower_bound(__middle, __last,
+           *__first_cut);
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut = std::upper_bound(__first, __middle,
+          *__second_cut);
+       __len11 = std::distance(__first, __first_cut);
+     }
+   _BidirectionalIterator __new_middle =
+     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+       __len1 - __len11, __len22, __buffer,
+       __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer, __buffer_size);
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size,
+       _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+         __first, __comp);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
+   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+           __buffer_end, __last, __comp);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+           __comp);
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+          __comp);
+       __len11 = std::distance(__first, __first_cut);
+     }
+   _BidirectionalIterator __new_middle =
+     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+       __len1 - __len11, __len22, __buffer,
+       __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Distance>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+      if (__len1 + __len2 == 2)
+ {
+   if (*__middle < *__first)
+     std::iter_swap(__first, __middle);
+   return;
+ }
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
+   __len11 = std::distance(__first, __first_cut);
+ }
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22);
+    }
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+                           _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2,
+      _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+      if (__len1 + __len2 == 2)
+ {
+   if (__comp(*__middle, *__first))
+     std::iter_swap(__first, __middle);
+   return;
+ }
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+       __comp);
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+      __comp);
+   __len11 = std::distance(__first, __first_cut);
+ }
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+  template<typename _BidirectionalIterator>
+    void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+          _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+          _DistanceType;
+      ;
+      ;
+      if (__first == __middle || __middle == __last)
+ return;
+      _DistanceType __len1 = std::distance(__first, __middle);
+      _DistanceType __len2 = std::distance(__middle, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+          __last);
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
+      else
+ std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
+         __buf.begin(), _DistanceType(__buf.size()));
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+          _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+          _DistanceType;
+      ;
+      ;
+      if (__first == __middle || __middle == __last)
+ return;
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+          __last);
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer(__first, __middle, __last, __len1,
+        __len2, __comp);
+      else
+ std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
+         __buf.begin(), _DistanceType(__buf.size()),
+         __comp);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first2 < *__first1)
+     {
+       *__result = (*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = (*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result))
+                  ;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first2, *__first1))
+     {
+       *__result = (*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = (*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1, __result))
+                  ;
+    }
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result,
+        _Distance __step_size)
+    {
+      const _Distance __two_step = 2 * __step_size;
+      while (__last - __first >= __two_step)
+ {
+   __result = std::__move_merge(__first, __first + __step_size,
+           __first + __step_size,
+           __first + __two_step, __result);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+      std::__move_merge(__first, __first + __step_size,
+   __first + __step_size, __last, __result);
+    }
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result, _Distance __step_size,
+        _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+      while (__last - __first >= __two_step)
+ {
+   __result = std::__move_merge(__first, __first + __step_size,
+           __first + __step_size,
+           __first + __two_step,
+           __result, __comp);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+      std::__move_merge(__first,__first + __step_size,
+   __first + __step_size, __last, __result, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Distance>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last);
+    }
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size, __comp);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+  enum { _S_chunk_size = 7 };
+  template<typename _RandomAccessIterator, typename _Pointer>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+                             _Pointer __buffer)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size);
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
+   __step_size *= 2;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+                             _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer,
+     __step_size, __comp);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first,
+     __step_size, __comp);
+   __step_size *= 2;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+                           _Pointer __buffer, _Distance __buffer_size)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle,
+          __buffer, __buffer_size);
+   std::__stable_sort_adaptive(__middle, __last,
+          __buffer, __buffer_size);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size);
+    }
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+                           _Pointer __buffer, _Distance __buffer_size,
+                           _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle, __buffer,
+          __buffer_size, __comp);
+   std::__stable_sort_adaptive(__middle, __last, __buffer,
+          __buffer_size, __comp);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size,
+       __comp);
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle);
+      std::__inplace_stable_sort(__middle, __last);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last, __comp);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle,
+      __comp);
+    }
+  template<typename _InputIterator1, typename _InputIterator2>
+    bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first2 < *__first1)
+   return false;
+ else if(*__first1 < *__first2)
+   ++__first1;
+ else
+   ++__first1, ++__first2;
+      return __first2 == __last2;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first2, *__first1))
+   return false;
+ else if(__comp(*__first1, *__first2))
+   ++__first1;
+ else
+   ++__first1, ++__first2;
+      return __first2 == __last2;
+    }
+  template<typename _BidirectionalIterator>
+    bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+      ;
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (*__i < *__ii)
+     {
+       _BidirectionalIterator __j = __last;
+       while (!(*__i < *--__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+      ;
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(*__i, *__ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!bool(__comp(*__i, *--__j)))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator>
+    bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+      ;
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (*__ii < *__i)
+     {
+       _BidirectionalIterator __j = __last;
+       while (!(*--__j < *__i))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+      ;
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(*__ii, *__i))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!bool(__comp(*--__j, *__i)))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+      ;
+      for (; __first != __last; ++__first, ++__result)
+ if (*__first == __old_value)
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+      ;
+      for (; __first != __last; ++__first, ++__result)
+ if (__pred(*__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+  template<typename _InputIterator, typename _Function>
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return (__f);
+    }
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+      ;
+      return std::__find(__first, __last, __val,
+           std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+      ;
+      return std::__find_if(__first, __last, __pred,
+       std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+      ;
+      ;
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+      ;
+      ;
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      ;
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while(++__next != __last)
+ {
+   if (*__first == *__next)
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+      ;
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while(++__next != __last)
+ {
+   if (__binary_pred(*__first, *__next))
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+  template<typename _InputIterator, typename _Tp>
+    typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+      ;
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (*__first == __value)
+   ++__n;
+      return __n;
+    }
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      ;
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   ++__n;
+      return __n;
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      ;
+      ;
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::find(__first1, __last1, *__first2);
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+      for (;;)
+ {
+   __first1 = std::find(__first1, __last1, *__first2);
+   if (__first1 == __last1)
+     return __last1;
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+   while (*__current == *__p)
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+      ;
+      ;
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ {
+   while (__first1 != __last1
+   && !bool(__predicate(*__first1, *__first2)))
+     ++__first1;
+   return __first1;
+ }
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+      for (;;)
+ {
+   while (__first1 != __last1
+   && !bool(__predicate(*__first1, *__first2)))
+     ++__first1;
+   if (__first1 == __last1)
+     return __last1;
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+   while (__predicate(*__current, *__p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+      ;
+      if (__count <= 0)
+ return __first;
+      if (__count == 1)
+ return std::find(__first, __last, __val);
+      return std::__search_n(__first, __last, __count, __val,
+        std::__iterator_category(__first));
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+      ;
+      if (__count <= 0)
+ return __first;
+      if (__count == 1)
+ {
+   while (__first != __last && !bool(__binary_pred(*__first, __val)))
+     ++__first;
+   return __first;
+ }
+      return std::__search_n(__first, __last, __count, __val, __binary_pred,
+        std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+      ;
+      for (; __first != __last; ++__first, ++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+      ;
+      for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, ++__first)
+ *__first = __gen();
+      return __first;
+    }
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+      ;
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+      ;
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result, __binary_pred,
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      ;
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
+    }
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _RandomNumberGenerator& __rand)
+    {
+      ;
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __rand((__i - __first) + 1));
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+      ;
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      std::__heap_select(__first, __middle, __last);
+      std::sort_heap(__first, __middle);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::sort_heap(__first, __middle, __comp);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      if (__first == __last || __nth == __last)
+ return;
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      ;
+      if (__first == __last || __nth == __last)
+ return;
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2, __comp);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2);
+   std::__final_insertion_sort(__first, __last);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      ;
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2, __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first2 < *__first1)
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first2, *__first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      ;
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
+         __last);
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()));
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      ;
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
+         __last);
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first1 < *__first2)
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (*__first2 < *__first1)
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first1, *__first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(*__first2, *__first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   ++__first1;
+ else if (*__first2 < *__first1)
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   ++__first1;
+ else if (__comp(*__first2, *__first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (*__first2 < *__first1)
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(*__first2, *__first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (*__first2 < *__first1)
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2, std::copy(__first1,
+          __last1, __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+      ;
+      ;
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(*__first2, *__first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      ;
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (*__first < *__result)
+   __result = __first;
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+      ;
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(*__first, *__result))
+   __result = __first;
+      return __result;
+    }
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      ;
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (*__result < *__first)
+   __result = __first;
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+      ;
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(*__result, *__first))
+   __result = __first;
+      return __result;
+    }
+}
+typedef signed char qint8;
+typedef unsigned char quint8;
+typedef short qint16;
+typedef unsigned short quint16;
+typedef int qint32;
+typedef unsigned int quint32;
+typedef long long qint64;
+typedef unsigned long long quint64;
+typedef qint64 qlonglong;
+typedef quint64 qulonglong;
+template <int> struct QIntegerForSize;
+template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; };
+template <> struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
+template <> struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
+template <> struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
+template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
+typedef QIntegerForSizeof<void*>::Unsigned quintptr;
+typedef QIntegerForSizeof<void*>::Signed qptrdiff;
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+typedef int QNoImplicitBoolCast;
+typedef double qreal;
+template <typename T>
+ inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
+ inline int qRound(qreal d)
+{ return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); }
+ inline qint64 qRound64(qreal d)
+{ return d >= qreal(0.0) ? qint64(d + qreal(0.5)) : qint64(d - qreal(qint64(d-1)) + qreal(0.5)) + qint64(d-1); }
+template <typename T>
+ inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; }
+template <typename T>
+ inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; }
+template <typename T>
+ inline const T &qBound(const T &min, const T &val, const T &max)
+{ return qMax(min, qMin(max, val)); }
+class QDataStream;
+inline void qt_noop(void) {}
+class QString;
+class QSysInfo {
+public:
+    enum Sizes {
+        WordSize = (sizeof(void *)<<3)
+    };
+    enum Endian {
+        BigEndian,
+        LittleEndian
+        , ByteOrder = BigEndian
+    };
+};
+ const char *qVersion();
+ bool qSharedBuild();
+ void qDebug(const char *, ...)
+    __attribute__ ((format (printf, 1, 2)))
+;
+ void qWarning(const char *, ...)
+    __attribute__ ((format (printf, 1, 2)))
+;
+class QString;
+ QString qt_error_string(int errorCode = -1);
+ void qCritical(const char *, ...)
+    __attribute__ ((format (printf, 1, 2)))
+;
+ void qFatal(const char *, ...)
+    __attribute__ ((format (printf, 1, 2)))
+;
+ void qErrnoWarning(int code, const char *msg, ...);
+ void qErrnoWarning(const char *msg, ...);
+class QDebug;
+class QNoDebug;
+ inline QDebug qDebug();
+ inline QDebug qWarning();
+ inline QDebug qCritical();
+ void qt_assert(const char *assertion, const char *file, int line);
+ void qt_assert_x(const char *where, const char *what, const char *file, int line);
+ void qt_check_pointer(const char *, int);
+ void qBadAlloc();
+template <typename T>
+inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (0); return p; }
+enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg };
+ void qt_message_output(QtMsgType, const char *buf);
+typedef void (*QtMsgHandler)(QtMsgType, const char *);
+ QtMsgHandler qInstallMsgHandler(QtMsgHandler);
+template <typename T> class QBasicAtomicPointer;
+template <typename T>
+class QGlobalStatic
+{
+public:
+    QBasicAtomicPointer<T> pointer;
+    bool destroyed;
+};
+template <typename T>
+class QGlobalStaticDeleter
+{
+public:
+    QGlobalStatic<T> &globalStatic;
+    QGlobalStaticDeleter(QGlobalStatic<T> &_globalStatic)
+        : globalStatic(_globalStatic)
+    { }
+    inline ~QGlobalStaticDeleter()
+    {
+        delete globalStatic.pointer;
+        globalStatic.pointer = 0;
+        globalStatic.destroyed = true;
+    }
+};
+class QBool
+{
+    bool b;
+public:
+    inline explicit QBool(bool B) : b(B) {}
+    inline operator const void *() const
+    { return b ? static_cast<const void *>(this) : static_cast<const void *>(0); }
+};
+inline bool operator==(QBool b1, bool b2) { return !b1 == !b2; }
+inline bool operator==(bool b1, QBool b2) { return !b1 == !b2; }
+inline bool operator==(QBool b1, QBool b2) { return !b1 == !b2; }
+inline bool operator!=(QBool b1, bool b2) { return !b1 != !b2; }
+inline bool operator!=(bool b1, QBool b2) { return !b1 != !b2; }
+inline bool operator!=(QBool b1, QBool b2) { return !b1 != !b2; }
+ static inline bool qFuzzyCompare(double p1, double p2)
+{
+    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
+}
+ static inline bool qFuzzyCompare(float p1, float p2)
+{
+    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
+}
+ static inline bool qFuzzyIsNull(double d)
+{
+    return qAbs(d) <= 0.000000000001;
+}
+ static inline bool qFuzzyIsNull(float f)
+{
+    return qAbs(f) <= 0.00001f;
+}
+static inline bool qIsNull(double d)
+{
+    union U {
+        double d;
+        quint64 u;
+    };
+    U val;
+    val.d = d;
+    return val.u == quint64(0);
+}
+static inline bool qIsNull(float f)
+{
+    union U {
+        float f;
+        quint32 u;
+    };
+    U val;
+    val.f = f;
+    return val.u == 0u;
+}
+template <typename T> inline bool qIsDetached(T &) { return true; }
+template <typename T>
+class QTypeInfo
+{
+public:
+    enum {
+        isPointer = false,
+        isComplex = true,
+        isStatic = true,
+        isLarge = (sizeof(T)>sizeof(void*)),
+        isDummy = false
+    };
+};
+template <typename T>
+class QTypeInfo<T*>
+{
+public:
+    enum {
+        isPointer = true,
+        isComplex = false,
+        isStatic = false,
+        isLarge = false,
+        isDummy = false
+    };
+};
+enum {
+    Q_COMPLEX_TYPE = 0,
+    Q_PRIMITIVE_TYPE = 0x1,
+    Q_STATIC_TYPE = 0,
+    Q_MOVABLE_TYPE = 0x2,
+    Q_DUMMY_TYPE = 0x4
+};
+template <typename T>
+inline void qSwap(T &value1, T &value2)
+{
+    using std::swap;
+    swap(value1, value2);
+}
+template<> class QTypeInfo<bool > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "bool"; } };
+template<> class QTypeInfo<char > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "char"; } };
+template<> class QTypeInfo<signed char > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "signed char"; } };
+template<> class QTypeInfo<uchar > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uchar"; } };
+template<> class QTypeInfo<short > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "short"; } };
+template<> class QTypeInfo<ushort > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ushort"; } };
+template<> class QTypeInfo<int > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "int"; } };
+template<> class QTypeInfo<uint > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uint"; } };
+template<> class QTypeInfo<long > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long"; } };
+template<> class QTypeInfo<ulong > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ulong"; } };
+template<> class QTypeInfo<qint64 > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "qint64"; } };
+template<> class QTypeInfo<quint64 > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "quint64"; } };
+template<> class QTypeInfo<float > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "float"; } };
+template<> class QTypeInfo<double > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "double"; } };
+template<> class QTypeInfo<long double > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long double"; } };
+ void *qMalloc(size_t size);
+ void qFree(void *ptr);
+ void *qRealloc(void *ptr, size_t size);
+ void *qMallocAligned(size_t size, size_t alignment);
+ void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment);
+ void qFreeAligned(void *ptr);
+ void *qMemCopy(void *dest, const void *src, size_t n);
+ void *qMemSet(void *dest, int c, size_t n);
+class QFlag
+{
+    int i;
+public:
+    inline QFlag(int i);
+    inline operator int() const { return i; }
+};
+inline QFlag::QFlag(int ai) : i(ai) {}
+class QIncompatibleFlag
+{
+    int i;
+public:
+    inline explicit QIncompatibleFlag(int i);
+    inline operator int() const { return i; }
+};
+inline QIncompatibleFlag::QIncompatibleFlag(int ai) : i(ai) {}
+template<typename Enum>
+class QFlags
+{
+    typedef void **Zero;
+    int i;
+public:
+    typedef Enum enum_type;
+    inline QFlags(const QFlags &f) : i(f.i) {}
+    inline QFlags(Enum f) : i(f) {}
+    inline QFlags(Zero = 0) : i(0) {}
+    inline QFlags(QFlag f) : i(f) {}
+    inline QFlags &operator=(const QFlags &f) { i = f.i; return *this; }
+    inline QFlags &operator&=(int mask) { i &= mask; return *this; }
+    inline QFlags &operator&=(uint mask) { i &= mask; return *this; }
+    inline QFlags &operator|=(QFlags f) { i |= f.i; return *this; }
+    inline QFlags &operator|=(Enum f) { i |= f; return *this; }
+    inline QFlags &operator^=(QFlags f) { i ^= f.i; return *this; }
+    inline QFlags &operator^=(Enum f) { i ^= f; return *this; }
+    inline operator int() const { return i; }
+    inline QFlags operator|(QFlags f) const { return QFlags(Enum(i | f.i)); }
+    inline QFlags operator|(Enum f) const { return QFlags(Enum(i | f)); }
+    inline QFlags operator^(QFlags f) const { return QFlags(Enum(i ^ f.i)); }
+    inline QFlags operator^(Enum f) const { return QFlags(Enum(i ^ f)); }
+    inline QFlags operator&(int mask) const { return QFlags(Enum(i & mask)); }
+    inline QFlags operator&(uint mask) const { return QFlags(Enum(i & mask)); }
+    inline QFlags operator&(Enum f) const { return QFlags(Enum(i & f)); }
+    inline QFlags operator~() const { return QFlags(Enum(~i)); }
+    inline bool operator!() const { return !i; }
+    inline bool testFlag(Enum f) const { return (i & f) == f && (f != 0 || i == int(f) ); }
+};
+template <typename T>
+class QForeachContainer {
+public:
+    inline QForeachContainer(const T& t) : c(t), brk(0), i(c.begin()), e(c.end()) { }
+    const T c;
+    int brk;
+    typename T::const_iterator i, e;
+};
+template <typename T> static inline T *qGetPtrHelper(T *ptr) { return ptr; }
+template <typename Wrapper> static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); }
+ QString qtTrId(const char *id, int n = -1);
+class QByteArray;
+ QByteArray qgetenv(const char *varName);
+ bool qputenv(const char *varName, const QByteArray& value);
+inline int qIntCast(double f) { return int(f); }
+inline int qIntCast(float f) { return int(f); }
+ void qsrand(uint seed);
+ int qrand();
+enum QtValidLicenseForCoreModule { LicensedCore = true };
+enum QtValidLicenseForGuiModule { LicensedGui = true };
+enum QtValidLicenseForNetworkModule { LicensedNetwork = true };
+enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true };
+enum QtValidLicenseForOpenVGModule { LicensedOpenVG = true };
+enum QtValidLicenseForSqlModule { LicensedSql = true };
+enum QtValidLicenseForMultimediaModule { LicensedMultimedia = true };
+enum QtValidLicenseForXmlModule { LicensedXml = true };
+enum QtValidLicenseForXmlPatternsModule { LicensedXmlPatterns = true };
+enum QtValidLicenseForHelpModule { LicensedHelp = true };
+enum QtValidLicenseForScriptModule { LicensedScript = true };
+enum QtValidLicenseForScriptToolsModule { LicensedScriptTools = true };
+enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true };
+enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true };
+enum QtValidLicenseForSvgModule { LicensedSvg = true };
+enum QtValidLicenseForDeclarativeModule { LicensedDeclarative = true };
+enum QtValidLicenseForActiveQtModule { LicensedActiveQt = true };
+enum QtValidLicenseForTestModule { LicensedTest = true };
+enum QtValidLicenseForDBusModule { LicensedDBus = true };
+namespace QtPrivate {
+template <bool B, typename T = void> struct QEnableIf;
+template <typename T> struct QEnableIf<true, T> { typedef T Type; };
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QAlgorithmsPrivate {
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+}
+template <typename InputIterator, typename OutputIterator>
+inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
+{
+    while (begin != end)
+        *dest++ = *begin++;
+    return dest;
+}
+template <typename BiIterator1, typename BiIterator2>
+inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
+{
+    while (begin != end)
+        *--dest = *--end;
+    return dest;
+}
+template <typename InputIterator1, typename InputIterator2>
+inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
+    for (; first1 != last1; ++first1, ++first2)
+        if (!(*first1 == *first2))
+            return false;
+    return true;
+}
+template <typename ForwardIterator, typename T>
+inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
+{
+    for (; first != last; ++first)
+        *first = val;
+}
+template <typename Container, typename T>
+inline void qFill(Container &container, const T &val)
+{
+    qFill(container.begin(), container.end(), val);
+}
+template <typename InputIterator, typename T>
+inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
+{
+    while (first != last && !(*first == val))
+        ++first;
+    return first;
+}
+template <typename Container, typename T>
+inline typename Container::const_iterator qFind(const Container &container, const T &val)
+{
+    return qFind(container.constBegin(), container.constEnd(), val);
+}
+template <typename InputIterator, typename T, typename Size>
+inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n)
+{
+    for (; first != last; ++first)
+        if (*first == value)
+            ++n;
+}
+template <typename Container, typename T, typename Size>
+inline void qCount(const Container &container, const T &value, Size &n)
+{
+    qCount(container.constBegin(), container.constEnd(), value, n);
+}
+template <typename T>
+class qLess
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t1 < t2);
+    }
+};
+template <typename T>
+class qGreater
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t2 < t1);
+    }
+};
+template <typename RandomAccessIterator>
+inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start);
+}
+template <typename RandomAccessIterator, typename LessThan>
+inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
+}
+template<typename Container>
+inline void qSort(Container &c)
+{
+    if (!c.empty())
+        QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
+}
+template <typename RandomAccessIterator>
+inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
+}
+template <typename RandomAccessIterator, typename LessThan>
+inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
+}
+template<typename Container>
+inline void qStableSort(Container &c)
+{
+    if (!c.empty())
+        QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
+}
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (*middle < value) {
+            begin = middle + 1;
+            n -= half + 1;
+        } else {
+            n = half;
+        }
+    }
+    return begin;
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
+}
+template <typename Container, typename T>
+ typename Container::const_iterator qLowerBound(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (value < *middle) {
+            n = half;
+        } else {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+    }
+    return begin;
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
+}
+template <typename Container, typename T>
+ typename Container::const_iterator qUpperBound(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+    RandomAccessIterator it = qLowerBound(begin, end, value);
+    if (it == end || value < *it)
+        return end;
+    return it;
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
+}
+template <typename Container, typename T>
+ typename Container::const_iterator qBinaryFind(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+template <typename ForwardIterator>
+ void qDeleteAll(ForwardIterator begin, ForwardIterator end)
+{
+    while (begin != end) {
+        delete *begin;
+        ++begin;
+    }
+}
+template <typename Container>
+inline void qDeleteAll(const Container &c)
+{
+    qDeleteAll(c.begin(), c.end());
+}
+namespace QAlgorithmsPrivate {
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan)
+{
+top:
+    int span = int(end - start);
+    if (span < 2)
+        return;
+    --end;
+    RandomAccessIterator low = start, high = end - 1;
+    RandomAccessIterator pivot = start + span / 2;
+    if (lessThan(*end, *start))
+        qSwap(*end, *start);
+    if (span == 2)
+        return;
+    if (lessThan(*pivot, *start))
+        qSwap(*pivot, *start);
+    if (lessThan(*end, *pivot))
+        qSwap(*end, *pivot);
+    if (span == 3)
+        return;
+    qSwap(*pivot, *end);
+    while (low < high) {
+        while (low < high && lessThan(*low, *end))
+            ++low;
+        while (high > low && lessThan(*end, *high))
+            --high;
+        if (low < high) {
+            qSwap(*low, *high);
+            ++low;
+            --high;
+        } else {
+            break;
+        }
+    }
+    if (lessThan(*low, *end))
+        ++low;
+    qSwap(*end, *low);
+    qSortHelper(start, low, t, lessThan);
+    start = low + 1;
+    ++end;
+    goto top;
+}
+template <typename RandomAccessIterator, typename T>
+inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qSortHelper(begin, end, dummy, qLess<T>());
+}
+template <typename RandomAccessIterator>
+ void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
+{
+    --end;
+    while (begin < end)
+        qSwap(*begin++, *end--);
+}
+template <typename RandomAccessIterator>
+ void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
+{
+    qReverse(begin, middle);
+    qReverse(middle, end);
+    qReverse(begin, end);
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan)
+{
+    const int len1 = pivot - begin;
+    const int len2 = end - pivot;
+    if (len1 == 0 || len2 == 0)
+        return;
+    if (len1 + len2 == 2) {
+        if (lessThan(*(begin + 1), *(begin)))
+            qSwap(*begin, *(begin + 1));
+        return;
+    }
+    RandomAccessIterator firstCut;
+    RandomAccessIterator secondCut;
+    int len2Half;
+    if (len1 > len2) {
+        const int len1Half = len1 / 2;
+        firstCut = begin + len1Half;
+        secondCut = qLowerBound(pivot, end, *firstCut, lessThan);
+        len2Half = secondCut - pivot;
+    } else {
+        len2Half = len2 / 2;
+        secondCut = pivot + len2Half;
+        firstCut = qUpperBound(begin, pivot, *secondCut, lessThan);
+    }
+    qRotate(firstCut, pivot, secondCut);
+    const RandomAccessIterator newPivot = firstCut + len2Half;
+    qMerge(begin, firstCut, newPivot, t, lessThan);
+    qMerge(newPivot, secondCut, end, t, lessThan);
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan)
+{
+    const int span = end - begin;
+    if (span < 2)
+       return;
+    const RandomAccessIterator middle = begin + span / 2;
+    qStableSortHelper(begin, middle, t, lessThan);
+    qStableSortHelper(middle, end, t, lessThan);
+    qMerge(begin, middle, end, t, lessThan);
+}
+template <typename RandomAccessIterator, typename T>
+inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qStableSortHelper(begin, end, dummy, qLess<T>());
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator middle;
+    int n = int(end - begin);
+    int half;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (lessThan(*middle, value)) {
+            begin = middle + 1;
+            n -= half + 1;
+        } else {
+            n = half;
+        }
+    }
+    return begin;
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (lessThan(value, *middle)) {
+            n = half;
+        } else {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+    }
+    return begin;
+}
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator it = qLowerBoundHelper(begin, end, value, lessThan);
+    if (it == end || lessThan(value, *it))
+        return end;
+    return it;
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T>
+struct QScopedPointerDeleter
+{
+    static inline void cleanup(T *pointer)
+    {
+        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
+        (void) sizeof(IsIncompleteType);
+        delete pointer;
+    }
+};
+template <typename T>
+struct QScopedPointerArrayDeleter
+{
+    static inline void cleanup(T *pointer)
+    {
+        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
+        (void) sizeof(IsIncompleteType);
+        delete [] pointer;
+    }
+};
+struct QScopedPointerPodDeleter
+{
+    static inline void cleanup(void *pointer) { if (pointer) qFree(pointer); }
+};
+template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
+class QScopedPointer
+{
+    typedef T *QScopedPointer:: *RestrictedBool;
+public:
+    explicit inline QScopedPointer(T *p = 0) : d(p)
+    {
+    }
+    inline ~QScopedPointer()
+    {
+        T *oldD = this->d;
+        Cleanup::cleanup(oldD);
+        this->d = 0;
+    }
+    inline T &operator*() const
+    {
+        qt_noop();
+        return *d;
+    }
+    inline T *operator->() const
+    {
+        qt_noop();
+        return d;
+    }
+    inline bool operator!() const
+    {
+        return !d;
+    }
+    inline operator RestrictedBool() const
+    {
+        return isNull() ? 0 : &QScopedPointer::d;
+    }
+    inline T *data() const
+    {
+        return d;
+    }
+    inline bool isNull() const
+    {
+        return !d;
+    }
+    inline void reset(T *other = 0)
+    {
+        if (d == other)
+            return;
+        T *oldD = d;
+        d = other;
+        Cleanup::cleanup(oldD);
+    }
+    inline T *take()
+    {
+        T *oldD = d;
+        d = 0;
+        return oldD;
+    }
+    inline void swap(QScopedPointer<T, Cleanup> &other)
+    {
+        qSwap(d, other.d);
+    }
+    typedef T *pointer;
+protected:
+    T *d;
+private:
+    QScopedPointer(const QScopedPointer &); QScopedPointer &operator=(const QScopedPointer &);
+};
+template <class T, class Cleanup>
+inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+{
+    return lhs.data() == rhs.data();
+}
+template <class T, class Cleanup>
+inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+{
+    return lhs.data() != rhs.data();
+}
+template <class T, class Cleanup>
+inline void qSwap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2)
+{ p1.swap(p2); }
+namespace std {
+    template <class T, class Cleanup>
+    inline void swap(::QScopedPointer<T, Cleanup> &p1, ::QScopedPointer<T, Cleanup> &p2)
+    { p1.swap(p2); }
+}
+namespace QtPrivate {
+    template <typename X, typename Y> struct QScopedArrayEnsureSameType;
+    template <typename X> struct QScopedArrayEnsureSameType<X,X> { typedef X* Type; };
+    template <typename X> struct QScopedArrayEnsureSameType<const X, X> { typedef X* Type; };
+}
+template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
+class QScopedArrayPointer : public QScopedPointer<T, Cleanup>
+{
+public:
+    inline QScopedArrayPointer() : QScopedPointer<T, Cleanup>(0) {}
+    template <typename D>
+    explicit inline QScopedArrayPointer(D *p, typename QtPrivate::QScopedArrayEnsureSameType<T,D>::Type = 0)
+        : QScopedPointer<T, Cleanup>(p)
+    {
+    }
+    inline T &operator[](int i)
+    {
+        return this->d[i];
+    }
+    inline const T &operator[](int i) const
+    {
+        return this->d[i];
+    }
+private:
+    explicit inline QScopedArrayPointer(void *) {
+    }
+    QScopedArrayPointer(const QScopedArrayPointer &); QScopedArrayPointer &operator=(const QScopedArrayPointer &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace
+Qt {
+    enum GlobalColor {
+        color0,
+        color1,
+        black,
+        white,
+        darkGray,
+        gray,
+        lightGray,
+        red,
+        green,
+        blue,
+        cyan,
+        magenta,
+        yellow,
+        darkRed,
+        darkGreen,
+        darkBlue,
+        darkCyan,
+        darkMagenta,
+        darkYellow,
+        transparent
+    };
+    enum KeyboardModifier {
+        NoModifier = 0x00000000,
+        ShiftModifier = 0x02000000,
+        ControlModifier = 0x04000000,
+        AltModifier = 0x08000000,
+        MetaModifier = 0x10000000,
+        KeypadModifier = 0x20000000,
+        GroupSwitchModifier = 0x40000000,
+        KeyboardModifierMask = 0xfe000000
+    };
+    typedef QFlags<KeyboardModifier> KeyboardModifiers;
+    enum Modifier {
+        META = Qt::MetaModifier,
+        SHIFT = Qt::ShiftModifier,
+        CTRL = Qt::ControlModifier,
+        ALT = Qt::AltModifier,
+        MODIFIER_MASK = KeyboardModifierMask,
+        UNICODE_ACCEL = 0x00000000
+    };
+    enum MouseButton {
+        NoButton = 0x00000000,
+        LeftButton = 0x00000001,
+        RightButton = 0x00000002,
+        MidButton = 0x00000004,
+        MiddleButton = MidButton,
+        XButton1 = 0x00000008,
+        XButton2 = 0x00000010,
+        MouseButtonMask = 0x000000ff
+    };
+    typedef QFlags<MouseButton> MouseButtons;
+    enum Orientation {
+        Horizontal = 0x1,
+        Vertical = 0x2
+    };
+    typedef QFlags<Orientation> Orientations;
+    enum FocusPolicy {
+        NoFocus = 0,
+        TabFocus = 0x1,
+        ClickFocus = 0x2,
+        StrongFocus = TabFocus | ClickFocus | 0x8,
+        WheelFocus = StrongFocus | 0x4
+    };
+    enum SortOrder {
+        AscendingOrder,
+        DescendingOrder
+    };
+    enum TileRule {
+        StretchTile,
+        RepeatTile,
+        RoundTile
+    };
+    enum AlignmentFlag {
+        AlignLeft = 0x0001,
+        AlignLeading = AlignLeft,
+        AlignRight = 0x0002,
+        AlignTrailing = AlignRight,
+        AlignHCenter = 0x0004,
+        AlignJustify = 0x0008,
+        AlignAbsolute = 0x0010,
+        AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute,
+        AlignTop = 0x0020,
+        AlignBottom = 0x0040,
+        AlignVCenter = 0x0080,
+        AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter,
+        AlignCenter = AlignVCenter | AlignHCenter
+    };
+    typedef QFlags<AlignmentFlag> Alignment;
+    enum TextFlag {
+        TextSingleLine = 0x0100,
+        TextDontClip = 0x0200,
+        TextExpandTabs = 0x0400,
+        TextShowMnemonic = 0x0800,
+        TextWordWrap = 0x1000,
+        TextWrapAnywhere = 0x2000,
+        TextDontPrint = 0x4000,
+        TextIncludeTrailingSpaces = 0x08000000,
+        TextHideMnemonic = 0x8000,
+        TextJustificationForced = 0x10000,
+        TextForceLeftToRight = 0x20000,
+        TextForceRightToLeft = 0x40000,
+        TextLongestVariant = 0x80000,
+        TextBypassShaping = 0x100000
+    };
+    enum TextElideMode {
+        ElideLeft,
+        ElideRight,
+        ElideMiddle,
+        ElideNone
+    };
+    enum WindowType {
+        Widget = 0x00000000,
+        Window = 0x00000001,
+        Dialog = 0x00000002 | Window,
+        Sheet = 0x00000004 | Window,
+        Drawer = 0x00000006 | Window,
+        Popup = 0x00000008 | Window,
+        Tool = 0x0000000a | Window,
+        ToolTip = 0x0000000c | Window,
+        SplashScreen = 0x0000000e | Window,
+        Desktop = 0x00000010 | Window,
+        SubWindow = 0x00000012,
+        WindowType_Mask = 0x000000ff,
+        MSWindowsFixedSizeDialogHint = 0x00000100,
+        MSWindowsOwnDC = 0x00000200,
+        X11BypassWindowManagerHint = 0x00000400,
+        FramelessWindowHint = 0x00000800,
+        WindowTitleHint = 0x00001000,
+        WindowSystemMenuHint = 0x00002000,
+        WindowMinimizeButtonHint = 0x00004000,
+        WindowMaximizeButtonHint = 0x00008000,
+        WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint,
+        WindowContextHelpButtonHint = 0x00010000,
+        WindowShadeButtonHint = 0x00020000,
+        WindowStaysOnTopHint = 0x00040000,
+        CustomizeWindowHint = 0x02000000,
+        WindowStaysOnBottomHint = 0x04000000,
+        WindowCloseButtonHint = 0x08000000,
+        MacWindowToolBarButtonHint = 0x10000000,
+        BypassGraphicsProxyWidget = 0x20000000,
+        WindowOkButtonHint = 0x00080000,
+        WindowCancelButtonHint = 0x00100000,
+        WindowSoftkeysVisibleHint = 0x40000000,
+        WindowSoftkeysRespondHint = 0x80000000
+    };
+    typedef QFlags<WindowType> WindowFlags;
+    enum WindowState {
+        WindowNoState = 0x00000000,
+        WindowMinimized = 0x00000001,
+        WindowMaximized = 0x00000002,
+        WindowFullScreen = 0x00000004,
+        WindowActive = 0x00000008
+    };
+    typedef QFlags<WindowState> WindowStates;
+    enum WidgetAttribute {
+        WA_Disabled = 0,
+        WA_UnderMouse = 1,
+        WA_MouseTracking = 2,
+        WA_ContentsPropagated = 3,
+        WA_OpaquePaintEvent = 4,
+        WA_NoBackground = WA_OpaquePaintEvent,
+        WA_StaticContents = 5,
+        WA_LaidOut = 7,
+        WA_PaintOnScreen = 8,
+        WA_NoSystemBackground = 9,
+        WA_UpdatesDisabled = 10,
+        WA_Mapped = 11,
+        WA_MacNoClickThrough = 12,
+        WA_PaintOutsidePaintEvent = 13,
+        WA_InputMethodEnabled = 14,
+        WA_WState_Visible = 15,
+        WA_WState_Hidden = 16,
+        WA_ForceDisabled = 32,
+        WA_KeyCompression = 33,
+        WA_PendingMoveEvent = 34,
+        WA_PendingResizeEvent = 35,
+        WA_SetPalette = 36,
+        WA_SetFont = 37,
+        WA_SetCursor = 38,
+        WA_NoChildEventsFromChildren = 39,
+        WA_WindowModified = 41,
+        WA_Resized = 42,
+        WA_Moved = 43,
+        WA_PendingUpdate = 44,
+        WA_InvalidSize = 45,
+        WA_MacBrushedMetal = 46,
+        WA_MacMetalStyle = WA_MacBrushedMetal,
+        WA_CustomWhatsThis = 47,
+        WA_LayoutOnEntireRect = 48,
+        WA_OutsideWSRange = 49,
+        WA_GrabbedShortcut = 50,
+        WA_TransparentForMouseEvents = 51,
+        WA_PaintUnclipped = 52,
+        WA_SetWindowIcon = 53,
+        WA_NoMouseReplay = 54,
+        WA_DeleteOnClose = 55,
+        WA_RightToLeft = 56,
+        WA_SetLayoutDirection = 57,
+        WA_NoChildEventsForParent = 58,
+        WA_ForceUpdatesDisabled = 59,
+        WA_WState_Created = 60,
+        WA_WState_CompressKeys = 61,
+        WA_WState_InPaintEvent = 62,
+        WA_WState_Reparented = 63,
+        WA_WState_ConfigPending = 64,
+        WA_WState_Polished = 66,
+        WA_WState_DND = 67,
+        WA_WState_OwnSizePolicy = 68,
+        WA_WState_ExplicitShowHide = 69,
+        WA_ShowModal = 70,
+        WA_MouseNoMask = 71,
+        WA_GroupLeader = 72,
+        WA_NoMousePropagation = 73,
+        WA_Hover = 74,
+        WA_InputMethodTransparent = 75,
+        WA_QuitOnClose = 76,
+        WA_KeyboardFocusChange = 77,
+        WA_AcceptDrops = 78,
+        WA_DropSiteRegistered = 79,
+        WA_ForceAcceptDrops = WA_DropSiteRegistered,
+        WA_WindowPropagation = 80,
+        WA_NoX11EventCompression = 81,
+        WA_TintedBackground = 82,
+        WA_X11OpenGLOverlay = 83,
+        WA_AlwaysShowToolTips = 84,
+        WA_MacOpaqueSizeGrip = 85,
+        WA_SetStyle = 86,
+        WA_SetLocale = 87,
+        WA_MacShowFocusRect = 88,
+        WA_MacNormalSize = 89,
+        WA_MacSmallSize = 90,
+        WA_MacMiniSize = 91,
+        WA_LayoutUsesWidgetRect = 92,
+        WA_StyledBackground = 93,
+        WA_MSWindowsUseDirect3D = 94,
+        WA_CanHostQMdiSubWindowTitleBar = 95,
+        WA_MacAlwaysShowToolWindow = 96,
+        WA_StyleSheet = 97,
+        WA_ShowWithoutActivating = 98,
+        WA_X11BypassTransientForHint = 99,
+        WA_NativeWindow = 100,
+        WA_DontCreateNativeAncestors = 101,
+        WA_MacVariableSize = 102,
+        WA_DontShowOnScreen = 103,
+        WA_X11NetWmWindowTypeDesktop = 104,
+        WA_X11NetWmWindowTypeDock = 105,
+        WA_X11NetWmWindowTypeToolBar = 106,
+        WA_X11NetWmWindowTypeMenu = 107,
+        WA_X11NetWmWindowTypeUtility = 108,
+        WA_X11NetWmWindowTypeSplash = 109,
+        WA_X11NetWmWindowTypeDialog = 110,
+        WA_X11NetWmWindowTypeDropDownMenu = 111,
+        WA_X11NetWmWindowTypePopupMenu = 112,
+        WA_X11NetWmWindowTypeToolTip = 113,
+        WA_X11NetWmWindowTypeNotification = 114,
+        WA_X11NetWmWindowTypeCombo = 115,
+        WA_X11NetWmWindowTypeDND = 116,
+        WA_MacFrameworkScaled = 117,
+        WA_SetWindowModality = 118,
+        WA_WState_WindowOpacitySet = 119,
+        WA_TranslucentBackground = 120,
+        WA_AcceptTouchEvents = 121,
+        WA_WState_AcceptedTouchBeginEvent = 122,
+        WA_TouchPadAcceptSingleTouchEvents = 123,
+        WA_MergeSoftkeys = 124,
+        WA_MergeSoftkeysRecursively = 125,
+        WA_LockPortraitOrientation = 128,
+        WA_LockLandscapeOrientation = 129,
+        WA_AutoOrientation = 130,
+        WA_X11DoNotAcceptFocus = 132,
+        WA_SymbianNoSystemRotation = 133,
+        WA_MacNoShadow = 134,
+        WA_AttributeCount
+    };
+    enum ApplicationAttribute
+    {
+        AA_ImmediateWidgetCreation = 0,
+        AA_MSWindowsUseDirect3DByDefault = 1,
+        AA_DontShowIconsInMenus = 2,
+        AA_NativeWindows = 3,
+        AA_DontCreateNativeWidgetSiblings = 4,
+        AA_MacPluginApplication = 5,
+        AA_DontUseNativeMenuBar = 6,
+        AA_MacDontSwapCtrlAndMeta = 7,
+        AA_S60DontConstructApplicationPanes = 8,
+        AA_S60DisablePartialScreenInputMode = 9,
+        AA_X11InitThreads = 10,
+        AA_CaptureMultimediaKeys = 11,
+        AA_AttributeCount
+    };
+    enum ImageConversionFlag {
+        ColorMode_Mask = 0x00000003,
+        AutoColor = 0x00000000,
+        ColorOnly = 0x00000003,
+        MonoOnly = 0x00000002,
+        AlphaDither_Mask = 0x0000000c,
+        ThresholdAlphaDither = 0x00000000,
+        OrderedAlphaDither = 0x00000004,
+        DiffuseAlphaDither = 0x00000008,
+        NoAlpha = 0x0000000c,
+        Dither_Mask = 0x00000030,
+        DiffuseDither = 0x00000000,
+        OrderedDither = 0x00000010,
+        ThresholdDither = 0x00000020,
+        DitherMode_Mask = 0x000000c0,
+        AutoDither = 0x00000000,
+        PreferDither = 0x00000040,
+        AvoidDither = 0x00000080,
+        NoOpaqueDetection = 0x00000100,
+        NoFormatConversion = 0x00000200
+    };
+    typedef QFlags<ImageConversionFlag> ImageConversionFlags;
+    enum BGMode {
+        TransparentMode,
+        OpaqueMode
+    };
+    enum Key {
+        Key_Escape = 0x01000000,
+        Key_Tab = 0x01000001,
+        Key_Backtab = 0x01000002,
+        Key_Backspace = 0x01000003,
+        Key_Return = 0x01000004,
+        Key_Enter = 0x01000005,
+        Key_Insert = 0x01000006,
+        Key_Delete = 0x01000007,
+        Key_Pause = 0x01000008,
+        Key_Print = 0x01000009,
+        Key_SysReq = 0x0100000a,
+        Key_Clear = 0x0100000b,
+        Key_Home = 0x01000010,
+        Key_End = 0x01000011,
+        Key_Left = 0x01000012,
+        Key_Up = 0x01000013,
+        Key_Right = 0x01000014,
+        Key_Down = 0x01000015,
+        Key_PageUp = 0x01000016,
+        Key_PageDown = 0x01000017,
+        Key_Shift = 0x01000020,
+        Key_Control = 0x01000021,
+        Key_Meta = 0x01000022,
+        Key_Alt = 0x01000023,
+        Key_CapsLock = 0x01000024,
+        Key_NumLock = 0x01000025,
+        Key_ScrollLock = 0x01000026,
+        Key_F1 = 0x01000030,
+        Key_F2 = 0x01000031,
+        Key_F3 = 0x01000032,
+        Key_F4 = 0x01000033,
+        Key_F5 = 0x01000034,
+        Key_F6 = 0x01000035,
+        Key_F7 = 0x01000036,
+        Key_F8 = 0x01000037,
+        Key_F9 = 0x01000038,
+        Key_F10 = 0x01000039,
+        Key_F11 = 0x0100003a,
+        Key_F12 = 0x0100003b,
+        Key_F13 = 0x0100003c,
+        Key_F14 = 0x0100003d,
+        Key_F15 = 0x0100003e,
+        Key_F16 = 0x0100003f,
+        Key_F17 = 0x01000040,
+        Key_F18 = 0x01000041,
+        Key_F19 = 0x01000042,
+        Key_F20 = 0x01000043,
+        Key_F21 = 0x01000044,
+        Key_F22 = 0x01000045,
+        Key_F23 = 0x01000046,
+        Key_F24 = 0x01000047,
+        Key_F25 = 0x01000048,
+        Key_F26 = 0x01000049,
+        Key_F27 = 0x0100004a,
+        Key_F28 = 0x0100004b,
+        Key_F29 = 0x0100004c,
+        Key_F30 = 0x0100004d,
+        Key_F31 = 0x0100004e,
+        Key_F32 = 0x0100004f,
+        Key_F33 = 0x01000050,
+        Key_F34 = 0x01000051,
+        Key_F35 = 0x01000052,
+        Key_Super_L = 0x01000053,
+        Key_Super_R = 0x01000054,
+        Key_Menu = 0x01000055,
+        Key_Hyper_L = 0x01000056,
+        Key_Hyper_R = 0x01000057,
+        Key_Help = 0x01000058,
+        Key_Direction_L = 0x01000059,
+        Key_Direction_R = 0x01000060,
+        Key_Space = 0x20,
+        Key_Any = Key_Space,
+        Key_Exclam = 0x21,
+        Key_QuoteDbl = 0x22,
+        Key_NumberSign = 0x23,
+        Key_Dollar = 0x24,
+        Key_Percent = 0x25,
+        Key_Ampersand = 0x26,
+        Key_Apostrophe = 0x27,
+        Key_ParenLeft = 0x28,
+        Key_ParenRight = 0x29,
+        Key_Asterisk = 0x2a,
+        Key_Plus = 0x2b,
+        Key_Comma = 0x2c,
+        Key_Minus = 0x2d,
+        Key_Period = 0x2e,
+        Key_Slash = 0x2f,
+        Key_0 = 0x30,
+        Key_1 = 0x31,
+        Key_2 = 0x32,
+        Key_3 = 0x33,
+        Key_4 = 0x34,
+        Key_5 = 0x35,
+        Key_6 = 0x36,
+        Key_7 = 0x37,
+        Key_8 = 0x38,
+        Key_9 = 0x39,
+        Key_Colon = 0x3a,
+        Key_Semicolon = 0x3b,
+        Key_Less = 0x3c,
+        Key_Equal = 0x3d,
+        Key_Greater = 0x3e,
+        Key_Question = 0x3f,
+        Key_At = 0x40,
+        Key_A = 0x41,
+        Key_B = 0x42,
+        Key_C = 0x43,
+        Key_D = 0x44,
+        Key_E = 0x45,
+        Key_F = 0x46,
+        Key_G = 0x47,
+        Key_H = 0x48,
+        Key_I = 0x49,
+        Key_J = 0x4a,
+        Key_K = 0x4b,
+        Key_L = 0x4c,
+        Key_M = 0x4d,
+        Key_N = 0x4e,
+        Key_O = 0x4f,
+        Key_P = 0x50,
+        Key_Q = 0x51,
+        Key_R = 0x52,
+        Key_S = 0x53,
+        Key_T = 0x54,
+        Key_U = 0x55,
+        Key_V = 0x56,
+        Key_W = 0x57,
+        Key_X = 0x58,
+        Key_Y = 0x59,
+        Key_Z = 0x5a,
+        Key_BracketLeft = 0x5b,
+        Key_Backslash = 0x5c,
+        Key_BracketRight = 0x5d,
+        Key_AsciiCircum = 0x5e,
+        Key_Underscore = 0x5f,
+        Key_QuoteLeft = 0x60,
+        Key_BraceLeft = 0x7b,
+        Key_Bar = 0x7c,
+        Key_BraceRight = 0x7d,
+        Key_AsciiTilde = 0x7e,
+        Key_nobreakspace = 0x0a0,
+        Key_exclamdown = 0x0a1,
+        Key_cent = 0x0a2,
+        Key_sterling = 0x0a3,
+        Key_currency = 0x0a4,
+        Key_yen = 0x0a5,
+        Key_brokenbar = 0x0a6,
+        Key_section = 0x0a7,
+        Key_diaeresis = 0x0a8,
+        Key_copyright = 0x0a9,
+        Key_ordfeminine = 0x0aa,
+        Key_guillemotleft = 0x0ab,
+        Key_notsign = 0x0ac,
+        Key_hyphen = 0x0ad,
+        Key_registered = 0x0ae,
+        Key_macron = 0x0af,
+        Key_degree = 0x0b0,
+        Key_plusminus = 0x0b1,
+        Key_twosuperior = 0x0b2,
+        Key_threesuperior = 0x0b3,
+        Key_acute = 0x0b4,
+        Key_mu = 0x0b5,
+        Key_paragraph = 0x0b6,
+        Key_periodcentered = 0x0b7,
+        Key_cedilla = 0x0b8,
+        Key_onesuperior = 0x0b9,
+        Key_masculine = 0x0ba,
+        Key_guillemotright = 0x0bb,
+        Key_onequarter = 0x0bc,
+        Key_onehalf = 0x0bd,
+        Key_threequarters = 0x0be,
+        Key_questiondown = 0x0bf,
+        Key_Agrave = 0x0c0,
+        Key_Aacute = 0x0c1,
+        Key_Acircumflex = 0x0c2,
+        Key_Atilde = 0x0c3,
+        Key_Adiaeresis = 0x0c4,
+        Key_Aring = 0x0c5,
+        Key_AE = 0x0c6,
+        Key_Ccedilla = 0x0c7,
+        Key_Egrave = 0x0c8,
+        Key_Eacute = 0x0c9,
+        Key_Ecircumflex = 0x0ca,
+        Key_Ediaeresis = 0x0cb,
+        Key_Igrave = 0x0cc,
+        Key_Iacute = 0x0cd,
+        Key_Icircumflex = 0x0ce,
+        Key_Idiaeresis = 0x0cf,
+        Key_ETH = 0x0d0,
+        Key_Ntilde = 0x0d1,
+        Key_Ograve = 0x0d2,
+        Key_Oacute = 0x0d3,
+        Key_Ocircumflex = 0x0d4,
+        Key_Otilde = 0x0d5,
+        Key_Odiaeresis = 0x0d6,
+        Key_multiply = 0x0d7,
+        Key_Ooblique = 0x0d8,
+        Key_Ugrave = 0x0d9,
+        Key_Uacute = 0x0da,
+        Key_Ucircumflex = 0x0db,
+        Key_Udiaeresis = 0x0dc,
+        Key_Yacute = 0x0dd,
+        Key_THORN = 0x0de,
+        Key_ssharp = 0x0df,
+        Key_division = 0x0f7,
+        Key_ydiaeresis = 0x0ff,
+        Key_AltGr = 0x01001103,
+        Key_Multi_key = 0x01001120,
+        Key_Codeinput = 0x01001137,
+        Key_SingleCandidate = 0x0100113c,
+        Key_MultipleCandidate = 0x0100113d,
+        Key_PreviousCandidate = 0x0100113e,
+        Key_Mode_switch = 0x0100117e,
+        Key_Kanji = 0x01001121,
+        Key_Muhenkan = 0x01001122,
+        Key_Henkan = 0x01001123,
+        Key_Romaji = 0x01001124,
+        Key_Hiragana = 0x01001125,
+        Key_Katakana = 0x01001126,
+        Key_Hiragana_Katakana = 0x01001127,
+        Key_Zenkaku = 0x01001128,
+        Key_Hankaku = 0x01001129,
+        Key_Zenkaku_Hankaku = 0x0100112a,
+        Key_Touroku = 0x0100112b,
+        Key_Massyo = 0x0100112c,
+        Key_Kana_Lock = 0x0100112d,
+        Key_Kana_Shift = 0x0100112e,
+        Key_Eisu_Shift = 0x0100112f,
+        Key_Eisu_toggle = 0x01001130,
+        Key_Hangul = 0x01001131,
+        Key_Hangul_Start = 0x01001132,
+        Key_Hangul_End = 0x01001133,
+        Key_Hangul_Hanja = 0x01001134,
+        Key_Hangul_Jamo = 0x01001135,
+        Key_Hangul_Romaja = 0x01001136,
+        Key_Hangul_Jeonja = 0x01001138,
+        Key_Hangul_Banja = 0x01001139,
+        Key_Hangul_PreHanja = 0x0100113a,
+        Key_Hangul_PostHanja = 0x0100113b,
+        Key_Hangul_Special = 0x0100113f,
+        Key_Dead_Grave = 0x01001250,
+        Key_Dead_Acute = 0x01001251,
+        Key_Dead_Circumflex = 0x01001252,
+        Key_Dead_Tilde = 0x01001253,
+        Key_Dead_Macron = 0x01001254,
+        Key_Dead_Breve = 0x01001255,
+        Key_Dead_Abovedot = 0x01001256,
+        Key_Dead_Diaeresis = 0x01001257,
+        Key_Dead_Abovering = 0x01001258,
+        Key_Dead_Doubleacute = 0x01001259,
+        Key_Dead_Caron = 0x0100125a,
+        Key_Dead_Cedilla = 0x0100125b,
+        Key_Dead_Ogonek = 0x0100125c,
+        Key_Dead_Iota = 0x0100125d,
+        Key_Dead_Voiced_Sound = 0x0100125e,
+        Key_Dead_Semivoiced_Sound = 0x0100125f,
+        Key_Dead_Belowdot = 0x01001260,
+        Key_Dead_Hook = 0x01001261,
+        Key_Dead_Horn = 0x01001262,
+        Key_Back = 0x01000061,
+        Key_Forward = 0x01000062,
+        Key_Stop = 0x01000063,
+        Key_Refresh = 0x01000064,
+        Key_VolumeDown = 0x01000070,
+        Key_VolumeMute = 0x01000071,
+        Key_VolumeUp = 0x01000072,
+        Key_BassBoost = 0x01000073,
+        Key_BassUp = 0x01000074,
+        Key_BassDown = 0x01000075,
+        Key_TrebleUp = 0x01000076,
+        Key_TrebleDown = 0x01000077,
+        Key_MediaPlay = 0x01000080,
+        Key_MediaStop = 0x01000081,
+        Key_MediaPrevious = 0x01000082,
+        Key_MediaNext = 0x01000083,
+        Key_MediaRecord = 0x01000084,
+        Key_MediaPause = 0x1000085,
+        Key_MediaTogglePlayPause = 0x1000086,
+        Key_HomePage = 0x01000090,
+        Key_Favorites = 0x01000091,
+        Key_Search = 0x01000092,
+        Key_Standby = 0x01000093,
+        Key_OpenUrl = 0x01000094,
+        Key_LaunchMail = 0x010000a0,
+        Key_LaunchMedia = 0x010000a1,
+        Key_Launch0 = 0x010000a2,
+        Key_Launch1 = 0x010000a3,
+        Key_Launch2 = 0x010000a4,
+        Key_Launch3 = 0x010000a5,
+        Key_Launch4 = 0x010000a6,
+        Key_Launch5 = 0x010000a7,
+        Key_Launch6 = 0x010000a8,
+        Key_Launch7 = 0x010000a9,
+        Key_Launch8 = 0x010000aa,
+        Key_Launch9 = 0x010000ab,
+        Key_LaunchA = 0x010000ac,
+        Key_LaunchB = 0x010000ad,
+        Key_LaunchC = 0x010000ae,
+        Key_LaunchD = 0x010000af,
+        Key_LaunchE = 0x010000b0,
+        Key_LaunchF = 0x010000b1,
+        Key_MonBrightnessUp = 0x010000b2,
+        Key_MonBrightnessDown = 0x010000b3,
+        Key_KeyboardLightOnOff = 0x010000b4,
+        Key_KeyboardBrightnessUp = 0x010000b5,
+        Key_KeyboardBrightnessDown = 0x010000b6,
+        Key_PowerOff = 0x010000b7,
+        Key_WakeUp = 0x010000b8,
+        Key_Eject = 0x010000b9,
+        Key_ScreenSaver = 0x010000ba,
+        Key_WWW = 0x010000bb,
+        Key_Memo = 0x010000bc,
+        Key_LightBulb = 0x010000bd,
+        Key_Shop = 0x010000be,
+        Key_History = 0x010000bf,
+        Key_AddFavorite = 0x010000c0,
+        Key_HotLinks = 0x010000c1,
+        Key_BrightnessAdjust = 0x010000c2,
+        Key_Finance = 0x010000c3,
+        Key_Community = 0x010000c4,
+        Key_AudioRewind = 0x010000c5,
+        Key_BackForward = 0x010000c6,
+        Key_ApplicationLeft = 0x010000c7,
+        Key_ApplicationRight = 0x010000c8,
+        Key_Book = 0x010000c9,
+        Key_CD = 0x010000ca,
+        Key_Calculator = 0x010000cb,
+        Key_ToDoList = 0x010000cc,
+        Key_ClearGrab = 0x010000cd,
+        Key_Close = 0x010000ce,
+        Key_Copy = 0x010000cf,
+        Key_Cut = 0x010000d0,
+        Key_Display = 0x010000d1,
+        Key_DOS = 0x010000d2,
+        Key_Documents = 0x010000d3,
+        Key_Excel = 0x010000d4,
+        Key_Explorer = 0x010000d5,
+        Key_Game = 0x010000d6,
+        Key_Go = 0x010000d7,
+        Key_iTouch = 0x010000d8,
+        Key_LogOff = 0x010000d9,
+        Key_Market = 0x010000da,
+        Key_Meeting = 0x010000db,
+        Key_MenuKB = 0x010000dc,
+        Key_MenuPB = 0x010000dd,
+        Key_MySites = 0x010000de,
+        Key_News = 0x010000df,
+        Key_OfficeHome = 0x010000e0,
+        Key_Option = 0x010000e1,
+        Key_Paste = 0x010000e2,
+        Key_Phone = 0x010000e3,
+        Key_Calendar = 0x010000e4,
+        Key_Reply = 0x010000e5,
+        Key_Reload = 0x010000e6,
+        Key_RotateWindows = 0x010000e7,
+        Key_RotationPB = 0x010000e8,
+        Key_RotationKB = 0x010000e9,
+        Key_Save = 0x010000ea,
+        Key_Send = 0x010000eb,
+        Key_Spell = 0x010000ec,
+        Key_SplitScreen = 0x010000ed,
+        Key_Support = 0x010000ee,
+        Key_TaskPane = 0x010000ef,
+        Key_Terminal = 0x010000f0,
+        Key_Tools = 0x010000f1,
+        Key_Travel = 0x010000f2,
+        Key_Video = 0x010000f3,
+        Key_Word = 0x010000f4,
+        Key_Xfer = 0x010000f5,
+        Key_ZoomIn = 0x010000f6,
+        Key_ZoomOut = 0x010000f7,
+        Key_Away = 0x010000f8,
+        Key_Messenger = 0x010000f9,
+        Key_WebCam = 0x010000fa,
+        Key_MailForward = 0x010000fb,
+        Key_Pictures = 0x010000fc,
+        Key_Music = 0x010000fd,
+        Key_Battery = 0x010000fe,
+        Key_Bluetooth = 0x010000ff,
+        Key_WLAN = 0x01000100,
+        Key_UWB = 0x01000101,
+        Key_AudioForward = 0x01000102,
+        Key_AudioRepeat = 0x01000103,
+        Key_AudioRandomPlay = 0x01000104,
+        Key_Subtitle = 0x01000105,
+        Key_AudioCycleTrack = 0x01000106,
+        Key_Time = 0x01000107,
+        Key_Hibernate = 0x01000108,
+        Key_View = 0x01000109,
+        Key_TopMenu = 0x0100010a,
+        Key_PowerDown = 0x0100010b,
+        Key_Suspend = 0x0100010c,
+        Key_ContrastAdjust = 0x0100010d,
+        Key_LaunchG = 0x0100010e,
+        Key_LaunchH = 0x0100010f,
+        Key_MediaLast = 0x0100ffff,
+        Key_Select = 0x01010000,
+        Key_Yes = 0x01010001,
+        Key_No = 0x01010002,
+        Key_Cancel = 0x01020001,
+        Key_Printer = 0x01020002,
+        Key_Execute = 0x01020003,
+        Key_Sleep = 0x01020004,
+        Key_Play = 0x01020005,
+        Key_Zoom = 0x01020006,
+        Key_Context1 = 0x01100000,
+        Key_Context2 = 0x01100001,
+        Key_Context3 = 0x01100002,
+        Key_Context4 = 0x01100003,
+        Key_Call = 0x01100004,
+        Key_Hangup = 0x01100005,
+        Key_Flip = 0x01100006,
+        Key_ToggleCallHangup = 0x01100007,
+        Key_VoiceDial = 0x01100008,
+        Key_LastNumberRedial = 0x01100009,
+        Key_Camera = 0x01100020,
+        Key_CameraFocus = 0x01100021,
+        Key_unknown = 0x01ffffff
+    };
+    enum ArrowType {
+        NoArrow,
+        UpArrow,
+        DownArrow,
+        LeftArrow,
+        RightArrow
+    };
+    enum PenStyle {
+        NoPen,
+        SolidLine,
+        DashLine,
+        DotLine,
+        DashDotLine,
+        DashDotDotLine,
+        CustomDashLine
+        , MPenStyle = 0x0f
+    };
+    enum PenCapStyle {
+        FlatCap = 0x00,
+        SquareCap = 0x10,
+        RoundCap = 0x20,
+        MPenCapStyle = 0x30
+    };
+    enum PenJoinStyle {
+        MiterJoin = 0x00,
+        BevelJoin = 0x40,
+        RoundJoin = 0x80,
+        SvgMiterJoin = 0x100,
+        MPenJoinStyle = 0x1c0
+    };
+    enum BrushStyle {
+        NoBrush,
+        SolidPattern,
+        Dense1Pattern,
+        Dense2Pattern,
+        Dense3Pattern,
+        Dense4Pattern,
+        Dense5Pattern,
+        Dense6Pattern,
+        Dense7Pattern,
+        HorPattern,
+        VerPattern,
+        CrossPattern,
+        BDiagPattern,
+        FDiagPattern,
+        DiagCrossPattern,
+        LinearGradientPattern,
+        RadialGradientPattern,
+        ConicalGradientPattern,
+        TexturePattern = 24
+    };
+    enum SizeMode {
+        AbsoluteSize,
+        RelativeSize
+    };
+    enum UIEffect {
+        UI_General,
+        UI_AnimateMenu,
+        UI_FadeMenu,
+        UI_AnimateCombo,
+        UI_AnimateTooltip,
+        UI_FadeTooltip,
+        UI_AnimateToolBox
+    };
+    enum CursorShape {
+        ArrowCursor,
+        UpArrowCursor,
+        CrossCursor,
+        WaitCursor,
+        IBeamCursor,
+        SizeVerCursor,
+        SizeHorCursor,
+        SizeBDiagCursor,
+        SizeFDiagCursor,
+        SizeAllCursor,
+        BlankCursor,
+        SplitVCursor,
+        SplitHCursor,
+        PointingHandCursor,
+        ForbiddenCursor,
+        WhatsThisCursor,
+        BusyCursor,
+        OpenHandCursor,
+        ClosedHandCursor,
+        DragCopyCursor,
+        DragMoveCursor,
+        DragLinkCursor,
+        LastCursor = DragLinkCursor,
+        BitmapCursor = 24,
+        CustomCursor = 25
+    };
+    enum TextFormat {
+        PlainText,
+        RichText,
+        AutoText,
+        LogText
+    };
+    enum AspectRatioMode {
+        IgnoreAspectRatio,
+        KeepAspectRatio,
+        KeepAspectRatioByExpanding
+    };
+    enum AnchorAttribute {
+        AnchorName,
+        AnchorHref
+    };
+    enum DockWidgetArea {
+        LeftDockWidgetArea = 0x1,
+        RightDockWidgetArea = 0x2,
+        TopDockWidgetArea = 0x4,
+        BottomDockWidgetArea = 0x8,
+        DockWidgetArea_Mask = 0xf,
+        AllDockWidgetAreas = DockWidgetArea_Mask,
+        NoDockWidgetArea = 0
+    };
+    enum DockWidgetAreaSizes {
+        NDockWidgetAreas = 4
+    };
+    typedef QFlags<DockWidgetArea> DockWidgetAreas;
+    enum ToolBarArea {
+        LeftToolBarArea = 0x1,
+        RightToolBarArea = 0x2,
+        TopToolBarArea = 0x4,
+        BottomToolBarArea = 0x8,
+        ToolBarArea_Mask = 0xf,
+        AllToolBarAreas = ToolBarArea_Mask,
+        NoToolBarArea = 0
+    };
+    enum ToolBarAreaSizes {
+        NToolBarAreas = 4
+    };
+    typedef QFlags<ToolBarArea> ToolBarAreas;
+    enum DateFormat {
+        TextDate,
+        ISODate,
+        SystemLocaleDate,
+        LocalDate = SystemLocaleDate,
+        LocaleDate,
+        SystemLocaleShortDate,
+        SystemLocaleLongDate,
+        DefaultLocaleShortDate,
+        DefaultLocaleLongDate
+    };
+    enum TimeSpec {
+        LocalTime,
+        UTC,
+        OffsetFromUTC
+    };
+    enum DayOfWeek {
+        Monday = 1,
+        Tuesday = 2,
+        Wednesday = 3,
+        Thursday = 4,
+        Friday = 5,
+        Saturday = 6,
+        Sunday = 7
+    };
+    enum ScrollBarPolicy {
+        ScrollBarAsNeeded,
+        ScrollBarAlwaysOff,
+        ScrollBarAlwaysOn
+    };
+    enum CaseSensitivity {
+        CaseInsensitive,
+        CaseSensitive
+    };
+    enum Corner {
+        TopLeftCorner = 0x00000,
+        TopRightCorner = 0x00001,
+        BottomLeftCorner = 0x00002,
+        BottomRightCorner = 0x00003
+    };
+    enum ConnectionType {
+        AutoConnection,
+        DirectConnection,
+        QueuedConnection,
+        AutoCompatConnection,
+        BlockingQueuedConnection,
+        UniqueConnection = 0x80
+    };
+    enum ShortcutContext {
+        WidgetShortcut,
+        WindowShortcut,
+        ApplicationShortcut,
+        WidgetWithChildrenShortcut
+    };
+    enum FillRule {
+        OddEvenFill,
+        WindingFill
+    };
+    enum MaskMode {
+        MaskInColor,
+        MaskOutColor
+    };
+    enum ClipOperation {
+        NoClip,
+        ReplaceClip,
+        IntersectClip,
+        UniteClip
+    };
+    enum ItemSelectionMode {
+        ContainsItemShape = 0x0,
+        IntersectsItemShape = 0x1,
+        ContainsItemBoundingRect = 0x2,
+        IntersectsItemBoundingRect = 0x3
+    };
+    enum TransformationMode {
+        FastTransformation,
+        SmoothTransformation
+    };
+    enum Axis {
+        XAxis,
+        YAxis,
+        ZAxis
+    };
+    enum FocusReason {
+        MouseFocusReason,
+        TabFocusReason,
+        BacktabFocusReason,
+        ActiveWindowFocusReason,
+        PopupFocusReason,
+        ShortcutFocusReason,
+        MenuBarFocusReason,
+        OtherFocusReason,
+        NoFocusReason
+    };
+    enum ContextMenuPolicy {
+        NoContextMenu,
+        DefaultContextMenu,
+        ActionsContextMenu,
+        CustomContextMenu,
+        PreventContextMenu
+    };
+    enum InputMethodQuery {
+        ImMicroFocus,
+        ImFont,
+        ImCursorPosition,
+        ImSurroundingText,
+        ImCurrentSelection,
+        ImMaximumTextLength,
+        ImAnchorPosition
+    };
+    enum InputMethodHint {
+        ImhNone = 0x0,
+        ImhHiddenText = 0x1,
+        ImhNoAutoUppercase = 0x2,
+        ImhPreferNumbers = 0x4,
+        ImhPreferUppercase = 0x8,
+        ImhPreferLowercase = 0x10,
+        ImhNoPredictiveText = 0x20,
+        ImhDigitsOnly = 0x10000,
+        ImhFormattedNumbersOnly = 0x20000,
+        ImhUppercaseOnly = 0x40000,
+        ImhLowercaseOnly = 0x80000,
+        ImhDialableCharactersOnly = 0x100000,
+        ImhEmailCharactersOnly = 0x200000,
+        ImhUrlCharactersOnly = 0x400000,
+        ImhExclusiveInputMask = 0xffff0000
+    };
+    typedef QFlags<InputMethodHint> InputMethodHints;
+    enum ToolButtonStyle {
+        ToolButtonIconOnly,
+        ToolButtonTextOnly,
+        ToolButtonTextBesideIcon,
+        ToolButtonTextUnderIcon,
+        ToolButtonFollowStyle
+    };
+    enum LayoutDirection {
+        LeftToRight,
+        RightToLeft,
+        LayoutDirectionAuto
+    };
+    enum AnchorPoint {
+        AnchorLeft = 0,
+        AnchorHorizontalCenter,
+        AnchorRight,
+        AnchorTop,
+        AnchorVerticalCenter,
+        AnchorBottom
+    };
+    enum DropAction {
+        CopyAction = 0x1,
+        MoveAction = 0x2,
+        LinkAction = 0x4,
+        ActionMask = 0xff,
+        TargetMoveAction = 0x8002,
+        IgnoreAction = 0x0
+    };
+    typedef QFlags<DropAction> DropActions;
+    enum CheckState {
+        Unchecked,
+        PartiallyChecked,
+        Checked
+    };
+    enum ItemDataRole {
+        DisplayRole = 0,
+        DecorationRole = 1,
+        EditRole = 2,
+        ToolTipRole = 3,
+        StatusTipRole = 4,
+        WhatsThisRole = 5,
+        FontRole = 6,
+        TextAlignmentRole = 7,
+        BackgroundColorRole = 8,
+        BackgroundRole = 8,
+        TextColorRole = 9,
+        ForegroundRole = 9,
+        CheckStateRole = 10,
+        AccessibleTextRole = 11,
+        AccessibleDescriptionRole = 12,
+        SizeHintRole = 13,
+        InitialSortOrderRole = 14,
+        DisplayPropertyRole = 27,
+        DecorationPropertyRole = 28,
+        ToolTipPropertyRole = 29,
+        StatusTipPropertyRole = 30,
+        WhatsThisPropertyRole = 31,
+        UserRole = 32
+    };
+    enum ItemFlag {
+        NoItemFlags = 0,
+        ItemIsSelectable = 1,
+        ItemIsEditable = 2,
+        ItemIsDragEnabled = 4,
+        ItemIsDropEnabled = 8,
+        ItemIsUserCheckable = 16,
+        ItemIsEnabled = 32,
+        ItemIsTristate = 64
+    };
+    typedef QFlags<ItemFlag> ItemFlags;
+    enum MatchFlag {
+        MatchExactly = 0,
+        MatchContains = 1,
+        MatchStartsWith = 2,
+        MatchEndsWith = 3,
+        MatchRegExp = 4,
+        MatchWildcard = 5,
+        MatchFixedString = 8,
+        MatchCaseSensitive = 16,
+        MatchWrap = 32,
+        MatchRecursive = 64
+    };
+    typedef QFlags<MatchFlag> MatchFlags;
+    typedef unsigned long HANDLE;
+    typedef WindowFlags WFlags;
+    enum WindowModality {
+        NonModal,
+        WindowModal,
+        ApplicationModal
+    };
+    enum TextInteractionFlag {
+        NoTextInteraction = 0,
+        TextSelectableByMouse = 1,
+        TextSelectableByKeyboard = 2,
+        LinksAccessibleByMouse = 4,
+        LinksAccessibleByKeyboard = 8,
+        TextEditable = 16,
+        TextEditorInteraction = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable,
+        TextBrowserInteraction = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard
+    };
+    typedef QFlags<TextInteractionFlag> TextInteractionFlags;
+    enum EventPriority {
+        HighEventPriority = 1,
+        NormalEventPriority = 0,
+        LowEventPriority = -1
+    };
+    enum SizeHint {
+        MinimumSize,
+        PreferredSize,
+        MaximumSize,
+        MinimumDescent,
+        NSizeHints
+    };
+    enum WindowFrameSection {
+        NoSection,
+        LeftSection,
+        TopLeftSection,
+        TopSection,
+        TopRightSection,
+        RightSection,
+        BottomRightSection,
+        BottomSection,
+        BottomLeftSection,
+        TitleBarArea
+    };
+    enum Initialization {
+        Uninitialized
+    };
+    enum CoordinateSystem {
+        DeviceCoordinates,
+        LogicalCoordinates
+    };
+    enum TouchPointState {
+        TouchPointPressed = 0x01,
+        TouchPointMoved = 0x02,
+        TouchPointStationary = 0x04,
+        TouchPointReleased = 0x08,
+        TouchPointStateMask = 0x0f,
+        TouchPointPrimary = 0x10
+    };
+    typedef QFlags<TouchPointState> TouchPointStates;
+    enum GestureState
+    {
+        NoGesture,
+        GestureStarted = 1,
+        GestureUpdated = 2,
+        GestureFinished = 3,
+        GestureCanceled = 4
+    };
+    enum GestureType
+    {
+        TapGesture = 1,
+        TapAndHoldGesture = 2,
+        PanGesture = 3,
+        PinchGesture = 4,
+        SwipeGesture = 5,
+        CustomGesture = 0x0100,
+        LastGestureType = ~0u
+    };
+    enum GestureFlag
+    {
+        DontStartGestureOnChildren = 0x01,
+        ReceivePartialGestures = 0x02,
+        IgnoredGesturesPropagateToParent = 0x04
+    };
+    typedef QFlags<GestureFlag> GestureFlags;
+    enum NavigationMode
+    {
+        NavigationModeNone,
+        NavigationModeKeypadTabOrder,
+        NavigationModeKeypadDirectional,
+        NavigationModeCursorAuto,
+        NavigationModeCursorForceVisible
+    };
+    enum CursorMoveStyle {
+        LogicalMoveStyle,
+        VisualMoveStyle
+    };
+}
+ inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags<Qt::MouseButtons::enum_type>(f1) | f2; } inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, QFlags<Qt::MouseButtons::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags<Qt::Orientations::enum_type>(f1) | f2; } inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, QFlags<Qt::Orientations::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags<Qt::KeyboardModifiers::enum_type>(f1) | f2; } inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, QFlags<Qt::KeyboardModifiers::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags<Qt::WindowFlags::enum_type>(f1) | f2; } inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, QFlags<Qt::WindowFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags<Qt::Alignment::enum_type>(f1) | f2; } inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, QFlags<Qt::Alignment::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags<Qt::ImageConversionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, QFlags<Qt::ImageConversionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags<Qt::DockWidgetAreas::enum_type>(f1) | f2; } inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, QFlags<Qt::DockWidgetAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags<Qt::ToolBarAreas::enum_type>(f1) | f2; } inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, QFlags<Qt::ToolBarAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags<Qt::WindowStates::enum_type>(f1) | f2; } inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, QFlags<Qt::WindowStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags<Qt::DropActions::enum_type>(f1) | f2; } inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, QFlags<Qt::DropActions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags<Qt::ItemFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, QFlags<Qt::ItemFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags<Qt::MatchFlags::enum_type>(f1) | f2; } inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, QFlags<Qt::MatchFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags<Qt::TextInteractionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, QFlags<Qt::TextInteractionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) { return QFlags<Qt::InputMethodHints::enum_type>(f1) | f2; } inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, QFlags<Qt::InputMethodHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) { return QFlags<Qt::TouchPointStates::enum_type>(f1) | f2; } inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, QFlags<Qt::TouchPointStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) { return QFlags<Qt::GestureFlags::enum_type>(f1) | f2; } inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, QFlags<Qt::GestureFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef bool (*qInternalCallback)(void **);
+class QInternal {
+public:
+    enum PaintDeviceFlags {
+        UnknownDevice = 0x00,
+        Widget = 0x01,
+        Pixmap = 0x02,
+        Image = 0x03,
+        Printer = 0x04,
+        Picture = 0x05,
+        Pbuffer = 0x06,
+        FramebufferObject = 0x07,
+        CustomRaster = 0x08,
+        MacQuartz = 0x09,
+        PaintBuffer = 0x0a,
+        OpenGL = 0x0b
+    };
+    enum RelayoutType {
+        RelayoutNormal,
+        RelayoutDragging,
+        RelayoutDropped
+    };
+    enum Callback {
+        ConnectCallback,
+        DisconnectCallback,
+        AdoptCurrentThread,
+        EventNotifyCallback,
+        LastCallback
+    };
+    enum InternalFunction {
+        CreateThreadForAdoption,
+        RefAdoptedThread,
+        DerefAdoptedThread,
+        SetCurrentThreadToMainThread,
+        SetQObjectSender,
+        GetQObjectSender,
+        ResetQObjectSender,
+        LastInternalFunction
+    };
+    enum DockPosition {
+        LeftDock,
+        RightDock,
+        TopDock,
+        BottomDock,
+        DockCount
+    };
+    static bool registerCallback(Callback, qInternalCallback);
+    static bool unregisterCallback(Callback, qInternalCallback);
+    static bool activateCallbacks(Callback, void **);
+    static bool callFunction(InternalFunction func, void **);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QByteArray;
+class QString;
+template <typename T>
+inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; }
+template <typename T1, typename T2>
+inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
+ const char *qFlagLocation(const char *method);
+class QObject;
+class QMetaMethod;
+class QMetaEnum;
+class QMetaProperty;
+class QMetaClassInfo;
+class QGenericArgument
+{
+public:
+    inline QGenericArgument(const char *aName = 0, const void *aData = 0)
+        : _data(aData), _name(aName) {}
+    inline void *data() const { return const_cast<void *>(_data); }
+    inline const char *name() const { return _name; }
+private:
+    const void *_data;
+    const char *_name;
+};
+class QGenericReturnArgument: public QGenericArgument
+{
+public:
+    inline QGenericReturnArgument(const char *aName = 0, void *aData = 0)
+        : QGenericArgument(aName, aData)
+        {}
+};
+template <class T>
+class QArgument: public QGenericArgument
+{
+public:
+    inline QArgument(const char *aName, const T &aData)
+        : QGenericArgument(aName, static_cast<const void *>(&aData))
+        {}
+};
+template <class T>
+class QArgument<T &>: public QGenericArgument
+{
+public:
+    inline QArgument(const char *aName, T &aData)
+        : QGenericArgument(aName, static_cast<const void *>(&aData))
+        {}
+};
+template <typename T>
+class QReturnArgument: public QGenericReturnArgument
+{
+public:
+    inline QReturnArgument(const char *aName, T &aData)
+        : QGenericReturnArgument(aName, static_cast<void *>(&aData))
+        {}
+};
+struct QMetaObject
+{
+    const char *className() const;
+    const QMetaObject *superClass() const;
+    QObject *cast(QObject *obj) const;
+    const QObject *cast(const QObject *obj) const;
+    QString tr(const char *s, const char *c) const;
+    QString trUtf8(const char *s, const char *c) const;
+    QString tr(const char *s, const char *c, int n) const;
+    QString trUtf8(const char *s, const char *c, int n) const;
+    int methodOffset() const;
+    int enumeratorOffset() const;
+    int propertyOffset() const;
+    int classInfoOffset() const;
+    int constructorCount() const;
+    int methodCount() const;
+    int enumeratorCount() const;
+    int propertyCount() const;
+    int classInfoCount() const;
+    int indexOfConstructor(const char *constructor) const;
+    int indexOfMethod(const char *method) const;
+    int indexOfSignal(const char *signal) const;
+    int indexOfSlot(const char *slot) const;
+    int indexOfEnumerator(const char *name) const;
+    int indexOfProperty(const char *name) const;
+    int indexOfClassInfo(const char *name) const;
+    QMetaMethod constructor(int index) const;
+    QMetaMethod method(int index) const;
+    QMetaEnum enumerator(int index) const;
+    QMetaProperty property(int index) const;
+    QMetaClassInfo classInfo(int index) const;
+    QMetaProperty userProperty() const;
+    static bool checkConnectArgs(const char *signal, const char *method);
+    static QByteArray normalizedSignature(const char *method);
+    static QByteArray normalizedType(const char *type);
+    static bool connect(const QObject *sender, int signal_index,
+                        const QObject *receiver, int method_index,
+                        int type = 0, int *types = 0);
+    static bool disconnect(const QObject *sender, int signal_index,
+                           const QObject *receiver, int method_index);
+    static bool disconnectOne(const QObject *sender, int signal_index,
+                              const QObject *receiver, int method_index);
+    static void connectSlotsByName(QObject *o);
+    static void activate(QObject *sender, int signal_index, void **argv);
+    static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv);
+    static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);
+    static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv);
+    static void addGuard(QObject **ptr);
+    static void removeGuard(QObject **ptr);
+    static void changeGuard(QObject **ptr, QObject *o);
+    static bool invokeMethod(QObject *obj, const char *member,
+                             Qt::ConnectionType,
+                             QGenericReturnArgument ret,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument());
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             QGenericReturnArgument ret,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,
+                val4, val5, val6, val7, val8, val9);
+    }
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             Qt::ConnectionType type,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,
+                                 val3, val4, val5, val6, val7, val8, val9);
+    }
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,
+                val1, val2, val3, val4, val5, val6, val7, val8, val9);
+    }
+    QObject *newInstance(QGenericArgument val0 = QGenericArgument(0),
+                         QGenericArgument val1 = QGenericArgument(),
+                         QGenericArgument val2 = QGenericArgument(),
+                         QGenericArgument val3 = QGenericArgument(),
+                         QGenericArgument val4 = QGenericArgument(),
+                         QGenericArgument val5 = QGenericArgument(),
+                         QGenericArgument val6 = QGenericArgument(),
+                         QGenericArgument val7 = QGenericArgument(),
+                         QGenericArgument val8 = QGenericArgument(),
+                         QGenericArgument val9 = QGenericArgument()) const;
+    enum Call {
+        InvokeMetaMethod,
+        ReadProperty,
+        WriteProperty,
+        ResetProperty,
+        QueryPropertyDesignable,
+        QueryPropertyScriptable,
+        QueryPropertyStored,
+        QueryPropertyEditable,
+        QueryPropertyUser,
+        CreateInstance
+    };
+    int static_metacall(Call, int, void **) const;
+    static int metacall(QObject *, Call, int, void **);
+    struct {
+        const QMetaObject *superdata;
+        const char *stringdata;
+        const uint *data;
+        const void *extradata;
+    } d;
+};
+typedef const QMetaObject& (*QMetaObjectAccessor)();
+struct QMetaObjectExtraData
+{
+    const QMetaObject **objects;
+    typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
+    StaticMetacallFunction static_metacall;
+};
+inline const char *QMetaObject::className() const
+{ return d.stringdata; }
+inline const QMetaObject *QMetaObject::superClass() const
+{ return d.superdata; }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QString;
+struct QLatin1Char
+{
+public:
+    inline explicit QLatin1Char(char c) : ch(c) {}
+    inline char toLatin1() const { return ch; }
+    inline ushort unicode() const { return ushort(uchar(ch)); }
+private:
+    char ch;
+};
+class QChar {
+public:
+    QChar();
+    QChar(char c);
+    QChar(uchar c);
+    QChar(QLatin1Char ch);
+    QChar(uchar c, uchar r);
+    inline QChar(ushort rc) : ucs(rc){}
+    QChar(short rc);
+    QChar(uint rc);
+    QChar(int rc);
+    enum SpecialCharacter {
+        Null = 0x0000,
+        Nbsp = 0x00a0,
+        ReplacementCharacter = 0xfffd,
+        ObjectReplacementCharacter = 0xfffc,
+        ByteOrderMark = 0xfeff,
+        ByteOrderSwapped = 0xfffe,
+        ParagraphSeparator = 0x2029,
+        LineSeparator = 0x2028
+    };
+    QChar(SpecialCharacter sc);
+    enum Category
+    {
+        NoCategory,
+        Mark_NonSpacing,
+        Mark_SpacingCombining,
+        Mark_Enclosing,
+        Number_DecimalDigit,
+        Number_Letter,
+        Number_Other,
+        Separator_Space,
+        Separator_Line,
+        Separator_Paragraph,
+        Other_Control,
+        Other_Format,
+        Other_Surrogate,
+        Other_PrivateUse,
+        Other_NotAssigned,
+        Letter_Uppercase,
+        Letter_Lowercase,
+        Letter_Titlecase,
+        Letter_Modifier,
+        Letter_Other,
+        Punctuation_Connector,
+        Punctuation_Dash,
+        Punctuation_Open,
+        Punctuation_Close,
+        Punctuation_InitialQuote,
+        Punctuation_FinalQuote,
+        Punctuation_Other,
+        Symbol_Math,
+        Symbol_Currency,
+        Symbol_Modifier,
+        Symbol_Other,
+        Punctuation_Dask = Punctuation_Dash
+    };
+    enum Direction
+    {
+        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
+        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
+    };
+    enum Decomposition
+    {
+        NoDecomposition,
+        Canonical,
+        Font,
+        NoBreak,
+        Initial,
+        Medial,
+        Final,
+        Isolated,
+        Circle,
+        Super,
+        Sub,
+        Vertical,
+        Wide,
+        Narrow,
+        Small,
+        Square,
+        Compat,
+        Fraction
+    };
+    enum Joining
+    {
+        OtherJoining, Dual, Right, Center
+    };
+    enum CombiningClass
+    {
+        Combining_BelowLeftAttached = 200,
+        Combining_BelowAttached = 202,
+        Combining_BelowRightAttached = 204,
+        Combining_LeftAttached = 208,
+        Combining_RightAttached = 210,
+        Combining_AboveLeftAttached = 212,
+        Combining_AboveAttached = 214,
+        Combining_AboveRightAttached = 216,
+        Combining_BelowLeft = 218,
+        Combining_Below = 220,
+        Combining_BelowRight = 222,
+        Combining_Left = 224,
+        Combining_Right = 226,
+        Combining_AboveLeft = 228,
+        Combining_Above = 230,
+        Combining_AboveRight = 232,
+        Combining_DoubleBelow = 233,
+        Combining_DoubleAbove = 234,
+        Combining_IotaSubscript = 240
+    };
+    enum UnicodeVersion {
+        Unicode_Unassigned,
+        Unicode_1_1,
+        Unicode_2_0,
+        Unicode_2_1_2,
+        Unicode_3_0,
+        Unicode_3_1,
+        Unicode_3_2,
+        Unicode_4_0,
+        Unicode_4_1,
+        Unicode_5_0
+    };
+    Category category() const;
+    Direction direction() const;
+    Joining joining() const;
+    bool hasMirrored() const;
+    unsigned char combiningClass() const;
+    QChar mirroredChar() const;
+    QString decomposition() const;
+    Decomposition decompositionTag() const;
+    int digitValue() const;
+    QChar toLower() const;
+    QChar toUpper() const;
+    QChar toTitleCase() const;
+    QChar toCaseFolded() const;
+    UnicodeVersion unicodeVersion() const;
+    char toAscii() const;
+    inline char toLatin1() const;
+    inline ushort unicode() const { return ucs; }
+    inline ushort &unicode() { return const_cast<ushort&>(ucs); }
+    static QChar fromAscii(char c);
+    static QChar fromLatin1(char c);
+    inline bool isNull() const { return ucs == 0; }
+    bool isPrint() const;
+    bool isPunct() const;
+    bool isSpace() const;
+    bool isMark() const;
+    bool isLetter() const;
+    bool isNumber() const;
+    bool isLetterOrNumber() const;
+    bool isDigit() const;
+    bool isSymbol() const;
+    inline bool isLower() const { return category() == Letter_Lowercase; }
+    inline bool isUpper() const { return category() == Letter_Uppercase; }
+    inline bool isTitleCase() const { return category() == Letter_Titlecase; }
+    inline bool isHighSurrogate() const {
+        return ((ucs & 0xfc00) == 0xd800);
+    }
+    inline bool isLowSurrogate() const {
+        return ((ucs & 0xfc00) == 0xdc00);
+    }
+    inline uchar cell() const { return uchar(ucs & 0xff); }
+    inline uchar row() const { return uchar((ucs>>8)&0xff); }
+    inline void setCell(uchar cell);
+    inline void setRow(uchar row);
+    static inline bool isHighSurrogate(uint ucs4) {
+        return ((ucs4 & 0xfffffc00) == 0xd800);
+    }
+    static inline bool isLowSurrogate(uint ucs4) {
+        return ((ucs4 & 0xfffffc00) == 0xdc00);
+    }
+    static inline bool requiresSurrogates(uint ucs4) {
+        return (ucs4 >= 0x10000);
+    }
+    static inline uint surrogateToUcs4(ushort high, ushort low) {
+        return (uint(high)<<10) + low - 0x35fdc00;
+    }
+    static inline uint surrogateToUcs4(QChar high, QChar low) {
+        return (uint(high.ucs)<<10) + low.ucs - 0x35fdc00;
+    }
+    static inline ushort highSurrogate(uint ucs4) {
+        return ushort((ucs4>>10) + 0xd7c0);
+    }
+    static inline ushort lowSurrogate(uint ucs4) {
+        return ushort(ucs4%0x400 + 0xdc00);
+    }
+    static Category category(uint ucs4);
+    static Category category(ushort ucs2);
+    static Direction direction(uint ucs4);
+    static Direction direction(ushort ucs2);
+    static Joining joining(uint ucs4);
+    static Joining joining(ushort ucs2);
+    static unsigned char combiningClass(uint ucs4);
+    static unsigned char combiningClass(ushort ucs2);
+    static uint mirroredChar(uint ucs4);
+    static ushort mirroredChar(ushort ucs2);
+    static Decomposition decompositionTag(uint ucs4);
+    static int digitValue(uint ucs4);
+    static int digitValue(ushort ucs2);
+    static uint toLower(uint ucs4);
+    static ushort toLower(ushort ucs2);
+    static uint toUpper(uint ucs4);
+    static ushort toUpper(ushort ucs2);
+    static uint toTitleCase(uint ucs4);
+    static ushort toTitleCase(ushort ucs2);
+    static uint toCaseFolded(uint ucs4);
+    static ushort toCaseFolded(ushort ucs2);
+    static UnicodeVersion unicodeVersion(uint ucs4);
+    static UnicodeVersion unicodeVersion(ushort ucs2);
+    static UnicodeVersion currentUnicodeVersion();
+    static QString decomposition(uint ucs4);
+private:
+    ushort ucs;
+}
+;
+template<> class QTypeInfo<QChar > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QChar"; } };
+inline QChar::QChar() : ucs(0) {}
+inline char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); }
+inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); }
+inline QChar::QChar(uchar c, uchar r) : ucs(ushort((r << 8) | c)){}
+inline QChar::QChar(short rc) : ucs(ushort(rc)){}
+inline QChar::QChar(uint rc) : ucs(ushort(rc & 0xffff)){}
+inline QChar::QChar(int rc) : ucs(ushort(rc & 0xffff)){}
+inline QChar::QChar(SpecialCharacter s) : ucs(ushort(s)) {}
+inline QChar::QChar(QLatin1Char ch) : ucs(ch.unicode()) {}
+inline void QChar::setCell(uchar acell)
+{ ucs = ushort((ucs & 0xff00) + acell); }
+inline void QChar::setRow(uchar arow)
+{ ucs = ushort((ushort(arow)<<8) + (ucs&0xff)); }
+inline bool operator==(QChar c1, QChar c2) { return c1.unicode() == c2.unicode(); }
+inline bool operator!=(QChar c1, QChar c2) { return c1.unicode() != c2.unicode(); }
+inline bool operator<=(QChar c1, QChar c2) { return c1.unicode() <= c2.unicode(); }
+inline bool operator>=(QChar c1, QChar c2) { return c1.unicode() >= c2.unicode(); }
+inline bool operator<(QChar c1, QChar c2) { return c1.unicode() < c2.unicode(); }
+inline bool operator>(QChar c1, QChar c2) { return c1.unicode() > c2.unicode(); }
+ QDataStream &operator<<(QDataStream &, const QChar &);
+ QDataStream &operator>>(QDataStream &, QChar &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QBasicAtomicInt
+{
+public:
+    volatile int _q_value;
+    inline bool operator==(int value) const
+    {
+        return _q_value == value;
+    }
+    inline bool operator!=(int value) const
+    {
+        return _q_value != value;
+    }
+    inline bool operator!() const
+    {
+        return _q_value == 0;
+    }
+    inline operator int() const
+    {
+        return _q_value;
+    }
+    inline QBasicAtomicInt &operator=(int value)
+    {
+        _q_value = value;
+        return *this;
+    }
+    static bool isReferenceCountingNative();
+    static bool isReferenceCountingWaitFree();
+    bool ref();
+    bool deref();
+    static bool isTestAndSetNative();
+    static bool isTestAndSetWaitFree();
+    bool testAndSetRelaxed(int expectedValue, int newValue);
+    bool testAndSetAcquire(int expectedValue, int newValue);
+    bool testAndSetRelease(int expectedValue, int newValue);
+    bool testAndSetOrdered(int expectedValue, int newValue);
+    static bool isFetchAndStoreNative();
+    static bool isFetchAndStoreWaitFree();
+    int fetchAndStoreRelaxed(int newValue);
+    int fetchAndStoreAcquire(int newValue);
+    int fetchAndStoreRelease(int newValue);
+    int fetchAndStoreOrdered(int newValue);
+    static bool isFetchAndAddNative();
+    static bool isFetchAndAddWaitFree();
+    int fetchAndAddRelaxed(int valueToAdd);
+    int fetchAndAddAcquire(int valueToAdd);
+    int fetchAndAddRelease(int valueToAdd);
+    int fetchAndAddOrdered(int valueToAdd);
+};
+template <typename T>
+class QBasicAtomicPointer
+{
+public:
+    T * volatile _q_value;
+    inline bool operator==(T *value) const
+    {
+        return _q_value == value;
+    }
+    inline bool operator!=(T *value) const
+    {
+        return !operator==(value);
+    }
+    inline bool operator!() const
+    {
+        return operator==(0);
+    }
+    inline operator T *() const
+    {
+        return _q_value;
+    }
+    inline T *operator->() const
+    {
+        return _q_value;
+    }
+    inline QBasicAtomicPointer<T> &operator=(T *value)
+    {
+        _q_value = value;
+        return *this;
+    }
+    static bool isTestAndSetNative();
+    static bool isTestAndSetWaitFree();
+    bool testAndSetRelaxed(T *expectedValue, T *newValue);
+    bool testAndSetAcquire(T *expectedValue, T *newValue);
+    bool testAndSetRelease(T *expectedValue, T *newValue);
+    bool testAndSetOrdered(T *expectedValue, T *newValue);
+    static bool isFetchAndStoreNative();
+    static bool isFetchAndStoreWaitFree();
+    T *fetchAndStoreRelaxed(T *newValue);
+    T *fetchAndStoreAcquire(T *newValue);
+    T *fetchAndStoreRelease(T *newValue);
+    T *fetchAndStoreOrdered(T *newValue);
+    static bool isFetchAndAddNative();
+    static bool isFetchAndAddWaitFree();
+    T *fetchAndAddRelaxed(qptrdiff valueToAdd);
+    T *fetchAndAddAcquire(qptrdiff valueToAdd);
+    T *fetchAndAddRelease(qptrdiff valueToAdd);
+    T *fetchAndAddOrdered(qptrdiff valueToAdd);
+};
+inline bool QBasicAtomicInt::isReferenceCountingNative()
+{ return true; }
+inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+{ return false; }
+inline bool QBasicAtomicInt::isTestAndSetNative()
+{ return true; }
+inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+{ return false; }
+inline bool QBasicAtomicInt::isFetchAndStoreNative()
+{ return true; }
+inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+{ return false; }
+inline bool QBasicAtomicInt::isFetchAndAddNative()
+{ return true; }
+inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+{ return false; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isTestAndSetNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+{ return false; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+{ return false; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+{ return false; }
+inline bool QBasicAtomicInt::ref()
+{
+    register int originalValue;
+    register int newValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "addi   %[newValue], %[originalValue], %[one]\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&b" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [one] "i" (1)
+                 : "cc", "memory");
+    return newValue != 0;
+}
+inline bool QBasicAtomicInt::deref()
+{
+    register int originalValue;
+    register int newValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "addi   %[newValue], %[originalValue], %[minusOne]\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&b" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [minusOne] "i" (-1)
+                 : "cc", "memory");
+    return newValue != 0;
+}
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    register int result;
+    asm volatile("lwarx  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+12\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    register int result;
+    asm volatile("lwarx  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+16\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 "isync\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    register int result;
+    asm volatile("eieio\n"
+                 "lwarx  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+12\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    register int originalValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    register int originalValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 "isync\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    register int originalValue;
+    asm volatile("eieio\n"
+                 "lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    register int originalValue;
+    register int newValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd)
+                 : "cc", "memory");
+    return originalValue;
+}
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    register int originalValue;
+    register int newValue;
+    asm volatile("lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 "isync\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd)
+                 : "cc", "memory");
+    return originalValue;
+}
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    register int originalValue;
+    register int newValue;
+    asm volatile("eieio\n"
+                 "lwarx  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stwcx. %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd)
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    register void *result;
+    asm volatile("ldarx""  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+12\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    register void *result;
+    asm volatile("ldarx""  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+16\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 "isync\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    register void *result;
+    asm volatile("eieio\n"
+                 "ldarx""  %[result]," "%y[_q_value]" "\n"
+                 "xor.   %[result], %[result], %[expectedValue]\n"
+                 "bne    $+12\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-16\n"
+                 : [result] "=&r" (result),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [expectedValue] "r" (expectedValue),
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return result == 0;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    register T *originalValue;
+    asm volatile("ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    register T *originalValue;
+    asm volatile("ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 "isync\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    register T *originalValue;
+    asm volatile("eieio\n"
+                 "ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-8\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [newValue] "r" (newValue)
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+{
+    register T *originalValue;
+    register T *newValue;
+    asm volatile("ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd * sizeof(T))
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+{
+    register T *originalValue;
+    register T *newValue;
+    asm volatile("ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 "isync\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd * sizeof(T))
+                 : "cc", "memory");
+    return originalValue;
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+{
+    register T *originalValue;
+    register T *newValue;
+    asm volatile("eieio\n"
+                 "ldarx""  %[originalValue]," "%y[_q_value]" "\n"
+                 "add    %[newValue], %[originalValue], %[valueToAdd]\n"
+                 "stdcx.""  %[newValue]," "%y[_q_value]" "\n"
+                 "bne-   $-12\n"
+                 : [originalValue] "=&r" (originalValue),
+                   [newValue] "=&r" (newValue),
+                   [_q_value] "+Z" (_q_value)
+                 :
+                   [valueToAdd] "r" (valueToAdd * sizeof(T))
+                 : "cc", "memory");
+    return originalValue;
+}
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    return testAndSetAcquire(expectedValue, newValue);
+}
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    return fetchAndStoreAcquire(newValue);
+}
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    return fetchAndAddAcquire(valueToAdd);
+}
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    return testAndSetAcquire(expectedValue, newValue);
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    return fetchAndStoreAcquire(newValue);
+}
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    return fetchAndAddAcquire(valueToAdd);
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAtomicInt : public QBasicAtomicInt
+{
+public:
+    inline QAtomicInt(int value = 0)
+    {
+        _q_value = value;
+    }
+    inline QAtomicInt(const QAtomicInt &other)
+    {
+        _q_value = other._q_value;
+    }
+    inline QAtomicInt &operator=(int value)
+    {
+        (void) QBasicAtomicInt::operator=(value);
+        return *this;
+    }
+    inline QAtomicInt &operator=(const QAtomicInt &other)
+    {
+        (void) QBasicAtomicInt::operator=(other);
+        return *this;
+    }
+};
+template <typename T>
+class QAtomicPointer : public QBasicAtomicPointer<T>
+{
+public:
+    inline QAtomicPointer(T *value = 0)
+    {
+        QBasicAtomicPointer<T>::_q_value = value;
+    }
+    inline QAtomicPointer(const QAtomicPointer<T> &other)
+    {
+        QBasicAtomicPointer<T>::_q_value = other._q_value;
+    }
+    inline QAtomicPointer<T> &operator=(T *value)
+    {
+        (void) QBasicAtomicPointer<T>::operator=(value);
+        return *this;
+    }
+    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other)
+    {
+        (void) QBasicAtomicPointer<T>::operator=(other);
+        return *this;
+    }
+};
+template <typename T>
+inline void qAtomicAssign(T *&d, T *x)
+{
+    if (d == x)
+        return;
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+template <typename T>
+inline void qAtomicDetach(T *&d)
+{
+    if (d->ref == 1)
+        return;
+    T *x = d;
+    d = new T(*d);
+    if (!x->ref.deref())
+        delete x;
+}
+extern "C" {
+extern void *memcpy (void *__restrict __dest,
+       __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *memmove (void *__dest, __const void *__src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
+        int __c, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++"
+{
+extern void *memchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const void *memchr (__const void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+memchr (void *__s, int __c, size_t __n) throw ()
+{
+  return __builtin_memchr (__s, __c, __n);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const void *
+memchr (__const void *__s, int __c, size_t __n) throw ()
+{
+  return __builtin_memchr (__s, __c, __n);
+}
+}
+extern "C++" void *rawmemchr (void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const void *rawmemchr (__const void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" void *memrchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const void *memrchr (__const void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *strncpy (char *__restrict __dest,
+        __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
+        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int strcmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int strcoll (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern size_t strxfrm (char *__restrict __dest,
+         __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
+    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
+extern char *strdup (__const char *__s)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+extern char *strndup (__const char *__string, size_t __n)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+extern "C++"
+{
+extern char *strchr (char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *strchr (__const char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strchr (char *__s, int __c) throw ()
+{
+  return __builtin_strchr (__s, __c);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strchr (__const char *__s, int __c) throw ()
+{
+  return __builtin_strchr (__s, __c);
+}
+}
+extern "C++"
+{
+extern char *strrchr (char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *strrchr (__const char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strrchr (char *__s, int __c) throw ()
+{
+  return __builtin_strrchr (__s, __c);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strrchr (__const char *__s, int __c) throw ()
+{
+  return __builtin_strrchr (__s, __c);
+}
+}
+extern "C++" char *strchrnul (char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const char *strchrnul (__const char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern size_t strcspn (__const char *__s, __const char *__reject)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern size_t strspn (__const char *__s, __const char *__accept)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++"
+{
+extern char *strpbrk (char *__s, __const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __const char *strpbrk (__const char *__s, __const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strpbrk (char *__s, __const char *__accept) throw ()
+{
+  return __builtin_strpbrk (__s, __accept);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strpbrk (__const char *__s, __const char *__accept) throw ()
+{
+  return __builtin_strpbrk (__s, __accept);
+}
+}
+extern "C++"
+{
+extern char *strstr (char *__haystack, __const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __const char *strstr (__const char *__haystack,
+        __const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strstr (char *__haystack, __const char *__needle) throw ()
+{
+  return __builtin_strstr (__haystack, __needle);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strstr (__const char *__haystack, __const char *__needle) throw ()
+{
+  return __builtin_strstr (__haystack, __needle);
+}
+}
+extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern char *__strtok_r (char *__restrict __s,
+    __const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+extern "C++" char *strcasestr (char *__haystack, __const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++" __const char *strcasestr (__const char *__haystack,
+           __const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern void *memmem (__const void *__haystack, size_t __haystacklen,
+       __const void *__needle, size_t __needlelen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
+extern void *__mempcpy (void *__restrict __dest,
+   __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *mempcpy (void *__restrict __dest,
+        __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern size_t strlen (__const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern size_t strnlen (__const char *__string, size_t __maxlen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern char *strerror (int __errnum) throw ();
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern char *strerror_l (int __errnum, __locale_t __l) throw ();
+extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+extern void bcopy (__const void *__src, void *__dest, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++"
+{
+extern char *index (char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *index (__const char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+index (char *__s, int __c) throw ()
+{
+  return __builtin_index (__s, __c);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+index (__const char *__s, int __c) throw ()
+{
+  return __builtin_index (__s, __c);
+}
+}
+extern "C++"
+{
+extern char *rindex (char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *rindex (__const char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+rindex (char *__s, int __c) throw ()
+{
+  return __builtin_rindex (__s, __c);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+rindex (__const char *__s, int __c) throw ()
+{
+  return __builtin_rindex (__s, __c);
+}
+}
+extern int ffs (int __i) throw () __attribute__ ((__const__));
+extern int ffsl (long int __l) throw () __attribute__ ((__const__));
+__extension__ extern int ffsll (long long int __ll)
+     throw () __attribute__ ((__const__));
+extern int strcasecmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int strcasecmp_l (__const char *__s1, __const char *__s2,
+    __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+extern int strncasecmp_l (__const char *__s1, __const char *__s2,
+     size_t __n, __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+extern char *strsep (char **__restrict __stringp,
+       __const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *strsignal (int __sig) throw ();
+extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *__stpncpy (char *__restrict __dest,
+   __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int strverscmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+extern "C++" char *basename (char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+extern "C++" __const char *basename (__const char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
+                                                                                                   ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+__attribute__ ((__leaf__)) memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()
+{
+  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+__attribute__ ((__leaf__)) memmove (void *__dest, __const void *__src, size_t __len) throw ()
+{
+  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+__attribute__ ((__leaf__)) mempcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()
+{
+  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+__attribute__ ((__leaf__)) memset (void *__dest, int __ch, size_t __len) throw ()
+{
+  if (__builtin_constant_p (__len) && __len == 0
+      && (!__builtin_constant_p (__ch) || __ch != 0))
+    {
+      __warn_memset_zero_len ();
+      return __dest;
+    }
+  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
+__attribute__ ((__leaf__)) bcopy (__const void *__src, void *__dest, size_t __len) throw ()
+{
+  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
+__attribute__ ((__leaf__)) bzero (void *__dest, size_t __len) throw ()
+{
+  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) strcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) stpcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()
+{
+  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
+}
+extern char *__stpncpy_chk (char *__dest, __const char *__src, size_t __n,
+       size_t __destlen) throw ();
+extern char *__stpncpy_alias (char *__dest, __const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) stpncpy (char *__dest, __const char *__src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
+      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
+    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
+  return __stpncpy_alias (__dest, __src, __n);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) strcat (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+__attribute__ ((__leaf__)) strncat (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()
+{
+  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
+}
+}
+typedef __gnuc_va_list va_list;
+typedef QtValidLicenseForCoreModule QtCoreModule;
+ char *qstrdup(const char *);
+inline uint qstrlen(const char *str)
+{ return str ? uint(strlen(str)) : 0; }
+inline uint qstrnlen(const char *str, uint maxlen)
+{
+    uint length = 0;
+    if (str) {
+        while (length < maxlen && *str++)
+            length++;
+    }
+    return length;
+}
+ char *qstrcpy(char *dst, const char *src);
+ char *qstrncpy(char *dst, const char *src, uint len);
+ int qstrcmp(const char *str1, const char *str2);
+ int qstrcmp(const QByteArray &str1, const QByteArray &str2);
+ int qstrcmp(const QByteArray &str1, const char *str2);
+static inline int qstrcmp(const char *str1, const QByteArray &str2)
+{ return -qstrcmp(str2, str1); }
+inline int qstrncmp(const char *str1, const char *str2, uint len)
+{
+    return (str1 && str2) ? strncmp(str1, str2, len)
+        : (str1 ? 1 : (str2 ? -1 : 0));
+}
+ int qstricmp(const char *, const char *);
+ int qstrnicmp(const char *, const char *, uint len);
+ int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap);
+ int qsnprintf(char *str, size_t n, const char *fmt, ...);
+ quint16 qChecksum(const char *s, uint len);
+class QByteRef;
+class QString;
+class QDataStream;
+template <typename T> class QList;
+class QByteArray
+{
+private:
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, size;
+        char *data;
+        char array[1];
+    };
+public:
+    inline QByteArray();
+    QByteArray(const char *);
+    QByteArray(const char *, int size);
+    QByteArray(int size, char c);
+    QByteArray(int size, Qt::Initialization);
+    inline QByteArray(const QByteArray &);
+    inline ~QByteArray();
+    QByteArray &operator=(const QByteArray &);
+    QByteArray &operator=(const char *str);
+    inline void swap(QByteArray &other) { qSwap(d, other.d); }
+    inline int size() const;
+    bool isEmpty() const;
+    void resize(int size);
+    QByteArray &fill(char c, int size = -1);
+    int capacity() const;
+    void reserve(int size);
+    void squeeze();
+    operator const char *() const;
+    operator const void *() const;
+    char *data();
+    const char *data() const;
+    inline const char *constData() const;
+    inline void detach();
+    bool isDetached() const;
+    inline bool isSharedWith(const QByteArray &other) const { return d == other.d; }
+    void clear();
+    char at(int i) const;
+    char operator[](int i) const;
+    char operator[](uint i) const;
+    QByteRef operator[](int i);
+    QByteRef operator[](uint i);
+    int indexOf(char c, int from = 0) const;
+    int indexOf(const char *c, int from = 0) const;
+    int indexOf(const QByteArray &a, int from = 0) const;
+    int lastIndexOf(char c, int from = -1) const;
+    int lastIndexOf(const char *c, int from = -1) const;
+    int lastIndexOf(const QByteArray &a, int from = -1) const;
+    QBool contains(char c) const;
+    QBool contains(const char *a) const;
+    QBool contains(const QByteArray &a) const;
+    int count(char c) const;
+    int count(const char *a) const;
+    int count(const QByteArray &a) const;
+    QByteArray left(int len) const;
+    QByteArray right(int len) const;
+    QByteArray mid(int index, int len = -1) const;
+    bool startsWith(const QByteArray &a) const;
+    bool startsWith(char c) const;
+    bool startsWith(const char *c) const;
+    bool endsWith(const QByteArray &a) const;
+    bool endsWith(char c) const;
+    bool endsWith(const char *c) const;
+    void truncate(int pos);
+    void chop(int n);
+    QByteArray toLower() const;
+    QByteArray toUpper() const;
+    QByteArray trimmed() const;
+    QByteArray simplified() const;
+    QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const;
+    QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const;
+    QByteArray &prepend(char c);
+    QByteArray &prepend(const char *s);
+    QByteArray &prepend(const char *s, int len);
+    QByteArray &prepend(const QByteArray &a);
+    QByteArray &append(char c);
+    QByteArray &append(const char *s);
+    QByteArray &append(const char *s, int len);
+    QByteArray &append(const QByteArray &a);
+    QByteArray &insert(int i, char c);
+    QByteArray &insert(int i, const char *s);
+    QByteArray &insert(int i, const char *s, int len);
+    QByteArray &insert(int i, const QByteArray &a);
+    QByteArray &remove(int index, int len);
+    QByteArray &replace(int index, int len, const char *s);
+    QByteArray &replace(int index, int len, const char *s, int alen);
+    QByteArray &replace(int index, int len, const QByteArray &s);
+    QByteArray &replace(char before, const char *after);
+    QByteArray &replace(char before, const QByteArray &after);
+    QByteArray &replace(const char *before, const char *after);
+    QByteArray &replace(const char *before, int bsize, const char *after, int asize);
+    QByteArray &replace(const QByteArray &before, const QByteArray &after);
+    QByteArray &replace(const QByteArray &before, const char *after);
+    QByteArray &replace(const char *before, const QByteArray &after);
+    QByteArray &replace(char before, char after);
+    QByteArray &operator+=(char c);
+    QByteArray &operator+=(const char *s);
+    QByteArray &operator+=(const QByteArray &a);
+    QList<QByteArray> split(char sep) const;
+    QByteArray repeated(int times) const;
+    QByteArray &append(const QString &s);
+    QByteArray &insert(int i, const QString &s);
+    QByteArray &replace(const QString &before, const char *after);
+    QByteArray &replace(char c, const QString &after);
+    QByteArray &replace(const QString &before, const QByteArray &after);
+    QByteArray &operator+=(const QString &s);
+    int indexOf(const QString &s, int from = 0) const;
+    int lastIndexOf(const QString &s, int from = -1) const;
+    inline bool operator==(const QString &s2) const;
+    inline bool operator!=(const QString &s2) const;
+    inline bool operator<(const QString &s2) const;
+    inline bool operator>(const QString &s2) const;
+    inline bool operator<=(const QString &s2) const;
+    inline bool operator>=(const QString &s2) const;
+    short toShort(bool *ok = 0, int base = 10) const;
+    ushort toUShort(bool *ok = 0, int base = 10) const;
+    int toInt(bool *ok = 0, int base = 10) const;
+    uint toUInt(bool *ok = 0, int base = 10) const;
+    long toLong(bool *ok = 0, int base = 10) const;
+    ulong toULong(bool *ok = 0, int base = 10) const;
+    qlonglong toLongLong(bool *ok = 0, int base = 10) const;
+    qulonglong toULongLong(bool *ok = 0, int base = 10) const;
+    float toFloat(bool *ok = 0) const;
+    double toDouble(bool *ok = 0) const;
+    QByteArray toBase64() const;
+    QByteArray toHex() const;
+    QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(),
+                                 const QByteArray &include = QByteArray(),
+                                 char percent = '%') const;
+    QByteArray &setNum(short, int base = 10);
+    QByteArray &setNum(ushort, int base = 10);
+    QByteArray &setNum(int, int base = 10);
+    QByteArray &setNum(uint, int base = 10);
+    QByteArray &setNum(qlonglong, int base = 10);
+    QByteArray &setNum(qulonglong, int base = 10);
+    QByteArray &setNum(float, char f = 'g', int prec = 6);
+    QByteArray &setNum(double, char f = 'g', int prec = 6);
+    QByteArray &setRawData(const char *a, uint n);
+    static QByteArray number(int, int base = 10);
+    static QByteArray number(uint, int base = 10);
+    static QByteArray number(qlonglong, int base = 10);
+    static QByteArray number(qulonglong, int base = 10);
+    static QByteArray number(double, char f = 'g', int prec = 6);
+    static QByteArray fromRawData(const char *, int size);
+    static QByteArray fromBase64(const QByteArray &base64);
+    static QByteArray fromHex(const QByteArray &hexEncoded);
+    static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%');
+    typedef char *iterator;
+    typedef const char *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator constBegin() const;
+    iterator end();
+    const_iterator end() const;
+    const_iterator constEnd() const;
+    typedef const char & const_reference;
+    typedef char & reference;
+    typedef char value_type;
+    void push_back(char c);
+    void push_back(const char *c);
+    void push_back(const QByteArray &a);
+    void push_front(char c);
+    void push_front(const char *c);
+    void push_front(const QByteArray &a);
+    inline int count() const { return d->size; }
+    int length() const { return d->size; }
+    bool isNull() const;
+private:
+    operator QNoImplicitBoolCast() const;
+    static Data shared_null;
+    static Data shared_empty;
+    Data *d;
+    QByteArray(Data *dd, int , int ) : d(dd) {}
+    void realloc(int alloc);
+    void expand(int i);
+    QByteArray nulTerminated() const;
+    friend class QByteRef;
+    friend class QString;
+    friend QByteArray qUncompress(const uchar *data, int nbytes);
+public:
+    typedef Data * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+inline QByteArray::QByteArray(): d(&shared_null) { d->ref.ref(); }
+inline QByteArray::~QByteArray() { if (!d->ref.deref()) qFree(d); }
+inline int QByteArray::size() const
+{ return d->size; }
+inline char QByteArray::at(int i) const
+{ qt_noop(); return d->data[i]; }
+inline char QByteArray::operator[](int i) const
+{ qt_noop(); return d->data[i]; }
+inline char QByteArray::operator[](uint i) const
+{ qt_noop(); return d->data[i]; }
+inline bool QByteArray::isEmpty() const
+{ return d->size == 0; }
+inline QByteArray::operator const char *() const
+{ return d->data; }
+inline QByteArray::operator const void *() const
+{ return d->data; }
+inline char *QByteArray::data()
+{ detach(); return d->data; }
+inline const char *QByteArray::data() const
+{ return d->data; }
+inline const char *QByteArray::constData() const
+{ return d->data; }
+inline void QByteArray::detach()
+{ if (d->ref != 1 || d->data != d->array) realloc(d->size); }
+inline bool QByteArray::isDetached() const
+{ return d->ref == 1; }
+inline QByteArray::QByteArray(const QByteArray &a) : d(a.d)
+{ d->ref.ref(); }
+inline int QByteArray::capacity() const
+{ return d->alloc; }
+inline void QByteArray::reserve(int asize)
+{ if (d->ref != 1 || asize > d->alloc) realloc(asize); }
+inline void QByteArray::squeeze()
+{ if (d->size < d->alloc) realloc(d->size); }
+class QByteRef {
+    QByteArray &a;
+    int i;
+    inline QByteRef(QByteArray &array, int idx)
+        : a(array),i(idx) {}
+    friend class QByteArray;
+public:
+    inline operator char() const
+        { return i < a.d->size ? a.d->data[i] : char(0); }
+    inline QByteRef &operator=(char c)
+        { if (i >= a.d->size) a.expand(i); else a.detach();
+          a.d->data[i] = c; return *this; }
+    inline QByteRef &operator=(const QByteRef &c)
+        { if (i >= a.d->size) a.expand(i); else a.detach();
+          a.d->data[i] = c.a.d->data[c.i]; return *this; }
+    inline bool operator==(char c) const
+    { return a.d->data[i] == c; }
+    inline bool operator!=(char c) const
+    { return a.d->data[i] != c; }
+    inline bool operator>(char c) const
+    { return a.d->data[i] > c; }
+    inline bool operator>=(char c) const
+    { return a.d->data[i] >= c; }
+    inline bool operator<(char c) const
+    { return a.d->data[i] < c; }
+    inline bool operator<=(char c) const
+    { return a.d->data[i] <= c; }
+};
+inline QByteRef QByteArray::operator[](int i)
+{ qt_noop(); return QByteRef(*this, i); }
+inline QByteRef QByteArray::operator[](uint i)
+{ return QByteRef(*this, i); }
+inline QByteArray::iterator QByteArray::begin()
+{ detach(); return d->data; }
+inline QByteArray::const_iterator QByteArray::begin() const
+{ return d->data; }
+inline QByteArray::const_iterator QByteArray::constBegin() const
+{ return d->data; }
+inline QByteArray::iterator QByteArray::end()
+{ detach(); return d->data + d->size; }
+inline QByteArray::const_iterator QByteArray::end() const
+{ return d->data + d->size; }
+inline QByteArray::const_iterator QByteArray::constEnd() const
+{ return d->data + d->size; }
+inline QByteArray &QByteArray::operator+=(char c)
+{ return append(c); }
+inline QByteArray &QByteArray::operator+=(const char *s)
+{ return append(s); }
+inline QByteArray &QByteArray::operator+=(const QByteArray &a)
+{ return append(a); }
+inline void QByteArray::push_back(char c)
+{ append(c); }
+inline void QByteArray::push_back(const char *c)
+{ append(c); }
+inline void QByteArray::push_back(const QByteArray &a)
+{ append(a); }
+inline void QByteArray::push_front(char c)
+{ prepend(c); }
+inline void QByteArray::push_front(const char *c)
+{ prepend(c); }
+inline void QByteArray::push_front(const QByteArray &a)
+{ prepend(a); }
+inline QBool QByteArray::contains(const QByteArray &a) const
+{ return QBool(indexOf(a) != -1); }
+inline QBool QByteArray::contains(char c) const
+{ return QBool(indexOf(c) != -1); }
+inline bool operator==(const QByteArray &a1, const QByteArray &a2)
+{ return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); }
+inline bool operator==(const QByteArray &a1, const char *a2)
+{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); }
+inline bool operator==(const char *a1, const QByteArray &a2)
+{ return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); }
+inline bool operator!=(const QByteArray &a1, const QByteArray &a2)
+{ return !(a1==a2); }
+inline bool operator!=(const QByteArray &a1, const char *a2)
+{ return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); }
+inline bool operator!=(const char *a1, const QByteArray &a2)
+{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); }
+inline bool operator<(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) < 0; }
+ inline bool operator<(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) < 0; }
+inline bool operator<(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) < 0; }
+inline bool operator<=(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator<=(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator<=(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator>(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>=(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline bool operator>=(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline bool operator>=(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const QByteArray &a1, const char *a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const QByteArray &a1, char a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const char *a1, const QByteArray &a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(char a1, const QByteArray &a2)
+{ return QByteArray(&a1, 1) += a2; }
+inline QBool QByteArray::contains(const char *c) const
+{ return QBool(indexOf(c) != -1); }
+inline QByteArray &QByteArray::replace(char before, const char *c)
+{ return replace(&before, 1, c, qstrlen(c)); }
+inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c)
+{ return replace(before.constData(), before.size(), c, qstrlen(c)); }
+inline QByteArray &QByteArray::replace(const char *before, const char *after)
+{ return replace(before, qstrlen(before), after, qstrlen(after)); }
+inline QByteArray &QByteArray::setNum(short n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QByteArray &QByteArray::setNum(ushort n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QByteArray &QByteArray::setNum(int n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QByteArray &QByteArray::setNum(uint n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QByteArray &QByteArray::setNum(float n, char f, int prec)
+{ return setNum(double(n),f,prec); }
+ QDataStream &operator<<(QDataStream &, const QByteArray &);
+ QDataStream &operator>>(QDataStream &, QByteArray &);
+ QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1);
+ QByteArray qUncompress(const uchar* data, int nbytes);
+inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1)
+{ return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }
+inline QByteArray qUncompress(const QByteArray& data)
+{ return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }
+template<> class QTypeInfo<QByteArray > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QByteArray"; } };
+template <> inline bool qIsDetached<QByteArray>(QByteArray &t) { return t.isDetached(); } template <> inline void qSwap<QByteArray>(QByteArray &value1, QByteArray &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QByteArray>(::QByteArray &value1, ::QByteArray &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+typedef std::basic_string<wchar_t> QStdWString;
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QCharRef;
+class QRegExp;
+class QStringList;
+class QTextCodec;
+class QLatin1String;
+class QStringRef;
+template <typename T> class QVector;
+class QString
+{
+public:
+    inline QString();
+    QString(const QChar *unicode, int size);
+    explicit QString(const QChar *unicode);
+    QString(QChar c);
+    QString(int size, QChar c);
+    inline QString(const QLatin1String &latin1);
+    inline QString(const QString &);
+    inline ~QString();
+    QString &operator=(QChar c);
+    QString &operator=(const QString &);
+    inline QString &operator=(const QLatin1String &);
+    inline void swap(QString &other) { qSwap(d, other.d); }
+    inline int size() const { return d->size; }
+    inline int count() const { return d->size; }
+    inline int length() const;
+    inline bool isEmpty() const;
+    void resize(int size);
+    QString &fill(QChar c, int size = -1);
+    void truncate(int pos);
+    void chop(int n);
+    int capacity() const;
+    inline void reserve(int size);
+    inline void squeeze() { if (d->size < d->alloc || d->ref != 1) realloc(); d->capacity = 0;}
+    inline const QChar *unicode() const;
+    inline QChar *data();
+    inline const QChar *data() const;
+    inline const QChar *constData() const;
+    inline void detach();
+    inline bool isDetached() const;
+    inline bool isSharedWith(const QString &other) const { return d == other.d; }
+    void clear();
+    inline const QChar at(int i) const;
+    const QChar operator[](int i) const;
+    QCharRef operator[](int i);
+    const QChar operator[](uint i) const;
+    QCharRef operator[](uint i);
+    QString arg(qlonglong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(qulonglong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(long a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(ulong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(int a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(uint a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(short a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(ushort a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(char a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(QChar a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7, const QString &a8) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7, const QString &a8, const QString &a9) const __attribute__ ((warn_unused_result));
+    QString &vsprintf(const char *format, va_list ap)
+        __attribute__ ((format (printf, 2, 0)))
+        ;
+    QString &sprintf(const char *format, ...)
+        __attribute__ ((format (printf, 2, 3)))
+        ;
+    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QRegExp &, int from = 0) const;
+    int lastIndexOf(const QRegExp &, int from = -1) const;
+    inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
+    int count(const QRegExp &) const;
+    int indexOf(QRegExp &, int from = 0) const;
+    int lastIndexOf(QRegExp &, int from = -1) const;
+    inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
+    enum SectionFlag {
+        SectionDefault = 0x00,
+        SectionSkipEmpty = 0x01,
+        SectionIncludeLeadingSep = 0x02,
+        SectionIncludeTrailingSep = 0x04,
+        SectionCaseInsensitiveSeps = 0x08
+    };
+    typedef QFlags<SectionFlag> SectionFlags;
+    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+    QString left(int n) const __attribute__ ((warn_unused_result));
+    QString right(int n) const __attribute__ ((warn_unused_result));
+    QString mid(int position, int n = -1) const __attribute__ ((warn_unused_result));
+    QStringRef leftRef(int n) const __attribute__ ((warn_unused_result));
+    QStringRef rightRef(int n) const __attribute__ ((warn_unused_result));
+    QStringRef midRef(int position, int n = -1) const __attribute__ ((warn_unused_result));
+    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result));
+    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result));
+    QString toLower() const __attribute__ ((warn_unused_result));
+    QString toUpper() const __attribute__ ((warn_unused_result));
+    QString toCaseFolded() const __attribute__ ((warn_unused_result));
+    QString trimmed() const __attribute__ ((warn_unused_result));
+    QString simplified() const __attribute__ ((warn_unused_result));
+    QString &insert(int i, QChar c);
+    QString &insert(int i, const QChar *uc, int len);
+    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
+    QString &insert(int i, const QLatin1String &s);
+    QString &append(QChar c);
+    QString &append(const QString &s);
+    QString &append(const QStringRef &s);
+    QString &append(const QLatin1String &s);
+    inline QString &prepend(QChar c) { return insert(0, c); }
+    inline QString &prepend(const QString &s) { return insert(0, s); }
+    inline QString &prepend(const QLatin1String &s) { return insert(0, s); }
+    inline QString &operator+=(QChar c) {
+        if (d->ref != 1 || d->size + 1 > d->alloc)
+            realloc(grow(d->size + 1));
+        d->data[d->size++] = c.unicode();
+        d->data[d->size] = '\0';
+        return *this;
+    }
+    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
+    inline QString &operator+=(const QString &s) { return append(s); }
+    inline QString &operator+=(const QStringRef &s) { return append(s); }
+    inline QString &operator+=(const QLatin1String &s) { return append(s); }
+    QString &remove(int i, int len);
+    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(int i, int len, QChar after);
+    QString &replace(int i, int len, const QChar *s, int slen);
+    QString &replace(int i, int len, const QString &after);
+    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QString &before, const QString &after,
+                     Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QRegExp &rx, const QString &after);
+    inline QString &remove(const QRegExp &rx)
+    { return replace(rx, QString()); }
+    enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };
+    QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result));
+    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result));
+    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((warn_unused_result));
+    enum NormalizationForm {
+        NormalizationForm_D,
+        NormalizationForm_C,
+        NormalizationForm_KD,
+        NormalizationForm_KC
+    };
+    QString normalized(NormalizationForm mode) const __attribute__ ((warn_unused_result));
+    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const __attribute__ ((warn_unused_result));
+    QString repeated(int times) const;
+    const ushort *utf16() const;
+    QByteArray toAscii() const __attribute__ ((warn_unused_result));
+    QByteArray toLatin1() const __attribute__ ((warn_unused_result));
+    QByteArray toUtf8() const __attribute__ ((warn_unused_result));
+    QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result));
+    QVector<uint> toUcs4() const __attribute__ ((warn_unused_result));
+    static QString fromAscii(const char *, int size = -1);
+    static QString fromLatin1(const char *, int size = -1);
+    static QString fromUtf8(const char *, int size = -1);
+    static QString fromLocal8Bit(const char *, int size = -1);
+    static QString fromUtf16(const ushort *, int size = -1);
+    static QString fromUcs4(const uint *, int size = -1);
+    static QString fromRawData(const QChar *, int size);
+    int toWCharArray(wchar_t *array) const;
+    static QString fromWCharArray(const wchar_t *, int size = -1);
+    QString &setRawData(const QChar *unicode, int size);
+    QString &setUnicode(const QChar *unicode, int size);
+    inline QString &setUtf16(const ushort *utf16, int size);
+    int compare(const QString &s) const;
+    int compare(const QString &s, Qt::CaseSensitivity cs) const;
+    int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    static inline int compare(const QString &s1, const QString &s2)
+    { return s1.compare(s2); }
+    static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs)
+    { return s1.compare(s2, cs); }
+    static inline int compare(const QString& s1, const QLatin1String &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
+    { return s1.compare(s2, cs); }
+    static inline int compare(const QLatin1String& s1, const QString &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
+    { return -s2.compare(s1, cs); }
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    static int compare(const QString &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+    int localeAwareCompare(const QString& s) const;
+    static int localeAwareCompare(const QString& s1, const QString& s2)
+    { return s1.localeAwareCompare(s2); }
+    int localeAwareCompare(const QStringRef &s) const;
+    static int localeAwareCompare(const QString& s1, const QStringRef& s2);
+    short toShort(bool *ok=0, int base=10) const;
+    ushort toUShort(bool *ok=0, int base=10) const;
+    int toInt(bool *ok=0, int base=10) const;
+    uint toUInt(bool *ok=0, int base=10) const;
+    long toLong(bool *ok=0, int base=10) const;
+    ulong toULong(bool *ok=0, int base=10) const;
+    qlonglong toLongLong(bool *ok=0, int base=10) const;
+    qulonglong toULongLong(bool *ok=0, int base=10) const;
+    float toFloat(bool *ok=0) const;
+    double toDouble(bool *ok=0) const;
+    QString &setNum(short, int base=10);
+    QString &setNum(ushort, int base=10);
+    QString &setNum(int, int base=10);
+    QString &setNum(uint, int base=10);
+    QString &setNum(long, int base=10);
+    QString &setNum(ulong, int base=10);
+    QString &setNum(qlonglong, int base=10);
+    QString &setNum(qulonglong, int base=10);
+    QString &setNum(float, char f='g', int prec=6);
+    QString &setNum(double, char f='g', int prec=6);
+    static QString number(int, int base=10);
+    static QString number(uint, int base=10);
+    static QString number(long, int base=10);
+    static QString number(ulong, int base=10);
+    static QString number(qlonglong, int base=10);
+    static QString number(qulonglong, int base=10);
+    static QString number(double, char f='g', int prec=6);
+    bool operator==(const QString &s) const;
+    bool operator<(const QString &s) const;
+    inline bool operator>(const QString &s) const { return s < *this; }
+    inline bool operator!=(const QString &s) const { return !operator==(s); }
+    inline bool operator<=(const QString &s) const { return !operator>(s); }
+    inline bool operator>=(const QString &s) const { return !operator<(s); }
+    bool operator==(const QLatin1String &s) const;
+    bool operator<(const QLatin1String &s) const;
+    bool operator>(const QLatin1String &s) const;
+    inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }
+    inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }
+    inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }
+    inline QString(const char *ch) : d(fromAscii_helper(ch))
+    {}
+    inline QString(const QByteArray &a)
+        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
+    {}
+    inline QString &operator=(const char *ch)
+    { return (*this = fromAscii(ch)); }
+    inline QString &operator=(const QByteArray &a)
+    { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); }
+    inline QString &operator=(char c)
+    { return (*this = QChar::fromAscii(c)); }
+    inline QString &prepend(const char *s)
+    { return prepend(QString::fromAscii(s)); }
+    inline QString &prepend(const QByteArray &s)
+    { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &append(const char *s)
+    { return append(QString::fromAscii(s)); }
+    inline QString &append(const QByteArray &s)
+    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &operator+=(const char *s)
+    { return append(QString::fromAscii(s)); }
+    inline QString &operator+=(const QByteArray &s)
+    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &operator+=(char c)
+    { return append(QChar::fromAscii(c)); }
+    inline bool operator==(const char *s) const;
+    inline bool operator!=(const char *s) const;
+    inline bool operator<(const char *s) const;
+    inline bool operator<=(const char *s2) const;
+    inline bool operator>(const char *s2) const;
+    inline bool operator>=(const char *s2) const;
+    inline bool operator==(const QByteArray &s) const;
+    inline bool operator!=(const QByteArray &s) const;
+    inline bool operator<(const QByteArray &s) const
+    { return *this < QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator>(const QByteArray &s) const
+    { return *this > QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator<=(const QByteArray &s) const
+    { return *this <= QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator>=(const QByteArray &s) const
+    { return *this >= QString::fromAscii(s.constData(), s.size()); }
+    typedef QChar *iterator;
+    typedef const QChar *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator constBegin() const;
+    iterator end();
+    const_iterator end() const;
+    const_iterator constEnd() const;
+    typedef const QChar & const_reference;
+    typedef QChar & reference;
+    typedef QChar value_type;
+    inline void push_back(QChar c) { append(c); }
+    inline void push_back(const QString &s) { append(s); }
+    inline void push_front(QChar c) { prepend(c); }
+    inline void push_front(const QString &s) { prepend(s); }
+    static inline QString fromStdString(const std::string &s);
+    inline std::string toStdString() const;
+    static inline QString fromStdWString(const QStdWString &s);
+    inline QStdWString toStdWString() const;
+    struct Null { };
+    static const Null null;
+    inline QString(const Null &): d(&shared_null) { d->ref.ref(); }
+    inline QString &operator=(const Null &) { *this = QString(); return *this; }
+    inline bool isNull() const { return d == &shared_null; }
+    bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
+    bool isRightToLeft() const;
+    QString(int size, Qt::Initialization);
+private:
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, size;
+        ushort *data;
+        ushort clean : 1;
+        ushort simpletext : 1;
+        ushort righttoleft : 1;
+        ushort asciiCache : 1;
+        ushort capacity : 1;
+        ushort reserved : 11;
+        ushort array[1];
+    };
+    static Data shared_null;
+    static Data shared_empty;
+    Data *d;
+    QString(Data *dd, int ) : d(dd) {}
+    static QTextCodec *codecForCStrings;
+    static int grow(int);
+    static void free(Data *);
+    void realloc();
+    void realloc(int alloc);
+    void expand(int i);
+    void updateProperties() const;
+    QString multiArg(int numArgs, const QString **args) const;
+    static int compare_helper(const QChar *data1, int length1,
+                              const QChar *data2, int length2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    static int compare_helper(const QChar *data1, int length1,
+                              QLatin1String s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    static int localeAwareCompare_helper(const QChar *data1, int length1,
+                                         const QChar *data2, int length2);
+    static Data *fromLatin1_helper(const char *str, int size = -1);
+    static Data *fromAscii_helper(const char *str, int size = -1);
+    void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
+    friend class QCharRef;
+    friend class QCFString;
+    friend class QTextCodec;
+    friend class QStringRef;
+    friend struct QAbstractConcatenable;
+    friend inline bool qStringComparisonHelper(const QString &s1, const char *s2);
+    friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2);
+public:
+    typedef Data * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+class QLatin1String
+{
+public:
+    inline explicit QLatin1String(const char *s) : chars(s) {}
+    inline QLatin1String &operator=(const QLatin1String &other)
+    { chars = other.chars; return *this; }
+    inline const char *latin1() const { return chars; }
+    inline bool operator==(const QString &s) const
+    { return s == *this; }
+    inline bool operator!=(const QString &s) const
+    { return s != *this; }
+    inline bool operator>(const QString &s) const
+    { return s < *this; }
+    inline bool operator<(const QString &s) const
+    { return s > *this; }
+    inline bool operator>=(const QString &s) const
+    { return s <= *this; }
+    inline bool operator<=(const QString &s) const
+    { return s >= *this; }
+    inline bool operator==(const char *s) const
+        { return QString::fromAscii(s) == *this; }
+    inline bool operator!=(const char *s) const
+        { return QString::fromAscii(s) != *this; }
+    inline bool operator<(const char *s) const
+        { return QString::fromAscii(s) > *this; }
+    inline bool operator>(const char *s) const
+        { return QString::fromAscii(s) < *this; }
+    inline bool operator<=(const char *s) const
+        { return QString::fromAscii(s) >= *this; }
+    inline bool operator>=(const char *s) const
+        { return QString::fromAscii(s) <= *this; }
+private:
+    const char *chars;
+};
+inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1()))
+{ }
+inline int QString::length() const
+{ return d->size; }
+inline const QChar QString::at(int i) const
+{ qt_noop(); return d->data[i]; }
+inline const QChar QString::operator[](int i) const
+{ qt_noop(); return d->data[i]; }
+inline const QChar QString::operator[](uint i) const
+{ qt_noop(); return d->data[i]; }
+inline bool QString::isEmpty() const
+{ return d->size == 0; }
+inline const QChar *QString::unicode() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline const QChar *QString::data() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QChar *QString::data()
+{ detach(); return reinterpret_cast<QChar*>(d->data); }
+inline const QChar *QString::constData() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline void QString::detach()
+{ if (d->ref != 1 || d->data != d->array) realloc(); }
+inline bool QString::isDetached() const
+{ return d->ref == 1; }
+inline QString &QString::operator=(const QLatin1String &s)
+{
+    *this = fromLatin1(s.latin1());
+    return *this;
+}
+inline void QString::clear()
+{ if (!isNull()) *this = QString(); }
+inline QString::QString(const QString &other) : d(other.d)
+{ qt_noop(); d->ref.ref(); }
+inline int QString::capacity() const
+{ return d->alloc; }
+inline QString &QString::setNum(short n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(ushort n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(int n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(uint n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(long n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(ulong n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(float n, char f, int prec)
+{ return setNum(double(n),f,prec); }
+inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(const QString &a1, const QString &a2) const
+{ const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
+{ const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4) const
+{ const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5) const
+{ const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6) const
+{ const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7) const
+{ const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7 }; return multiArg(7, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7, const QString &a8) const
+{ const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 }; return multiArg(8, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7, const QString &a8, const QString &a9) const
+{ const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9 }; return multiArg(9, args); }
+inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
+{ return section(QString(asep), astart, aend, aflags); }
+class QCharRef {
+    QString &s;
+    int i;
+    inline QCharRef(QString &str, int idx)
+        : s(str),i(idx) {}
+    friend class QString;
+public:
+    inline operator QChar() const
+        { return i < s.d->size ? s.d->data[i] : 0; }
+    inline QCharRef &operator=(const QChar &c)
+        { if (i >= s.d->size) s.expand(i); else s.detach();
+          s.d->data[i] = c.unicode(); return *this; }
+    inline QCharRef &operator=(char c)
+    { return operator=(QChar::fromAscii(c)); }
+    inline QCharRef &operator=(uchar c)
+    { return operator=(QChar::fromAscii(c)); }
+    inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
+    inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }
+    inline bool isNull() const { return QChar(*this).isNull(); }
+    inline bool isPrint() const { return QChar(*this).isPrint(); }
+    inline bool isPunct() const { return QChar(*this).isPunct(); }
+    inline bool isSpace() const { return QChar(*this).isSpace(); }
+    inline bool isMark() const { return QChar(*this).isMark(); }
+    inline bool isLetter() const { return QChar(*this).isLetter(); }
+    inline bool isNumber() const { return QChar(*this).isNumber(); }
+    inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
+    inline bool isDigit() const { return QChar(*this).isDigit(); }
+    inline bool isLower() const { return QChar(*this).isLower(); }
+    inline bool isUpper() const { return QChar(*this).isUpper(); }
+    inline bool isTitleCase() const { return QChar(*this).isTitleCase(); }
+    inline int digitValue() const { return QChar(*this).digitValue(); }
+    QChar toLower() const { return QChar(*this).toLower(); }
+    QChar toUpper() const { return QChar(*this).toUpper(); }
+    QChar toTitleCase () const { return QChar(*this).toTitleCase(); }
+    QChar::Category category() const { return QChar(*this).category(); }
+    QChar::Direction direction() const { return QChar(*this).direction(); }
+    QChar::Joining joining() const { return QChar(*this).joining(); }
+    bool hasMirrored() const { return QChar(*this).hasMirrored(); }
+    QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
+    QString decomposition() const { return QChar(*this).decomposition(); }
+    QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
+    uchar combiningClass() const { return QChar(*this).combiningClass(); }
+    QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }
+    inline uchar cell() const { return QChar(*this).cell(); }
+    inline uchar row() const { return QChar(*this).row(); }
+    inline void setCell(uchar cell);
+    inline void setRow(uchar row);
+    char toAscii() const { return QChar(*this).toAscii(); }
+    char toLatin1() const { return QChar(*this).toLatin1(); }
+    ushort unicode() const { return QChar(*this).unicode(); }
+    ushort& unicode() { return s.data()[i].unicode(); }
+};
+inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
+inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }
+inline QString::QString() : d(&shared_null) { d->ref.ref(); }
+inline QString::~QString() { if (!d->ref.deref()) free(d); }
+inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); d->capacity = 1;}
+inline QString &QString::setUtf16(const ushort *autf16, int asize)
+{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
+inline QCharRef QString::operator[](int i)
+{ qt_noop(); return QCharRef(*this, i); }
+inline QCharRef QString::operator[](uint i)
+{ return QCharRef(*this, i); }
+inline QString::iterator QString::begin()
+{ detach(); return reinterpret_cast<QChar*>(d->data); }
+inline QString::const_iterator QString::begin() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QString::const_iterator QString::constBegin() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QString::iterator QString::end()
+{ detach(); return reinterpret_cast<QChar*>(d->data + d->size); }
+inline QString::const_iterator QString::end() const
+{ return reinterpret_cast<const QChar*>(d->data + d->size); }
+inline QString::const_iterator QString::constEnd() const
+{ return reinterpret_cast<const QChar*>(d->data + d->size); }
+inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(c, 0, cs) != -1); }
+inline bool operator==(QString::Null, QString::Null) { return true; }
+inline bool operator==(QString::Null, const QString &s) { return s.isNull(); }
+inline bool operator==(const QString &s, QString::Null) { return s.isNull(); }
+inline bool operator!=(QString::Null, QString::Null) { return false; }
+inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); }
+inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); }
+inline bool qStringComparisonHelper(const QString &s1, const char *s2)
+{
+    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));
+    return (s1 == QLatin1String(s2));
+}
+inline bool QString::operator==(const char *s) const
+{ return qStringComparisonHelper(*this, s); }
+inline bool QString::operator!=(const char *s) const
+{ return !qStringComparisonHelper(*this, s); }
+inline bool QString::operator<(const char *s) const
+{ return *this < QString::fromAscii(s); }
+inline bool QString::operator>(const char *s) const
+{ return *this > QString::fromAscii(s); }
+inline bool QString::operator<=(const char *s) const
+{ return *this <= QString::fromAscii(s); }
+inline bool QString::operator>=(const char *s) const
+{ return *this >= QString::fromAscii(s); }
+inline bool operator==(const char *s1, const QString &s2)
+{ return qStringComparisonHelper(s2, s1); }
+inline bool operator!=(const char *s1, const QString &s2)
+{ return !qStringComparisonHelper(s2, s1); }
+inline bool operator<(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) < s2); }
+inline bool operator>(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) > s2); }
+inline bool operator<=(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) <= s2); }
+inline bool operator>=(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) >= s2); }
+inline bool operator==(const char *s1, const QLatin1String &s2)
+{ return QString::fromAscii(s1) == s2; }
+inline bool operator!=(const char *s1, const QLatin1String &s2)
+{ return QString::fromAscii(s1) != s2; }
+inline bool operator<(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) < s2); }
+inline bool operator>(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) > s2); }
+inline bool operator<=(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) <= s2); }
+inline bool operator>=(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) >= s2); }
+inline bool operator==(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) == 0); }
+inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) != 0); }
+inline bool operator<(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) < 0); }
+inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) <= 0); }
+inline bool operator>(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) > 0); }
+inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) >= 0); }
+inline bool QString::operator==(const QByteArray &s) const
+{ return qStringComparisonHelper(*this, s.constData()); }
+inline bool QString::operator!=(const QByteArray &s) const
+{ return !qStringComparisonHelper(*this, s.constData()); }
+inline bool QByteArray::operator==(const QString &s) const
+{ return qStringComparisonHelper(s, constData()); }
+inline bool QByteArray::operator!=(const QString &s) const
+{ return !qStringComparisonHelper(s, constData()); }
+inline bool QByteArray::operator<(const QString &s) const
+{ return QString::fromAscii(constData(), size()) < s; }
+inline bool QByteArray::operator>(const QString &s) const
+{ return QString::fromAscii(constData(), size()) > s; }
+inline bool QByteArray::operator<=(const QString &s) const
+{ return QString::fromAscii(constData(), size()) <= s; }
+inline bool QByteArray::operator>=(const QString &s) const
+{ return QString::fromAscii(constData(), size()) >= s; }
+inline QByteArray &QByteArray::append(const QString &s)
+{ return append(s.toAscii()); }
+inline QByteArray &QByteArray::insert(int i, const QString &s)
+{ return insert(i, s.toAscii()); }
+inline QByteArray &QByteArray::replace(char c, const QString &after)
+{ return replace(c, after.toAscii()); }
+inline QByteArray &QByteArray::replace(const QString &before, const char *after)
+{ return replace(before.toAscii(), after); }
+inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)
+{ return replace(before.toAscii(), after); }
+inline QByteArray &QByteArray::operator+=(const QString &s)
+{ return operator+=(s.toAscii()); }
+inline int QByteArray::indexOf(const QString &s, int from) const
+{ return indexOf(s.toAscii(), from); }
+inline int QByteArray::lastIndexOf(const QString &s, int from) const
+{ return lastIndexOf(s.toAscii(), from); }
+inline const QString operator+(const QString &s1, const QString &s2)
+{ QString t(s1); t += s2; return t; }
+inline const QString operator+(const QString &s1, QChar s2)
+{ QString t(s1); t += s2; return t; }
+inline const QString operator+(QChar s1, const QString &s2)
+{ QString t(s1); t += s2; return t; }
+inline const QString operator+(const QString &s1, const char *s2)
+{ QString t(s1); t += QString::fromAscii(s2); return t; }
+inline const QString operator+(const char *s1, const QString &s2)
+{ QString t = QString::fromAscii(s1); t += s2; return t; }
+inline const QString operator+(char c, const QString &s)
+{ QString t = s; t.prepend(QChar::fromAscii(c)); return t; }
+inline const QString operator+(const QString &s, char c)
+{ QString t = s; t += QChar::fromAscii(c); return t; }
+inline const QString operator+(const QByteArray &ba, const QString &s)
+{ QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; }
+inline const QString operator+(const QString &s, const QByteArray &ba)
+{ QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; }
+inline std::string QString::toStdString() const
+{ const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); }
+inline QString QString::fromStdString(const std::string &s)
+{ return fromAscii(s.data(), int(s.size())); }
+inline QStdWString QString::toStdWString() const
+{
+    QStdWString str;
+    str.resize(length());
+    str.resize(toWCharArray(&(*str.begin())));
+    return str;
+}
+inline QString QString::fromStdWString(const QStdWString &s)
+{ return fromWCharArray(s.data(), int(s.size())); }
+ QDataStream &operator<<(QDataStream &, const QString &);
+ QDataStream &operator>>(QDataStream &, QString &);
+template<> class QTypeInfo<QString > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QString"; } };
+template <> inline bool qIsDetached<QString>(QString &t) { return t.isDetached(); } template <> inline void qSwap<QString>(QString &value1, QString &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QString>(::QString &value1, ::QString &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+ inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+class QStringRef {
+    const QString *m_string;
+    int m_position;
+    int m_size;
+public:
+    inline QStringRef():m_string(0), m_position(0), m_size(0){}
+    inline QStringRef(const QString *string, int position, int size);
+    inline QStringRef(const QString *string);
+    inline QStringRef(const QStringRef &other)
+        :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
+        {}
+    inline ~QStringRef(){}
+    inline const QString *string() const { return m_string; }
+    inline int position() const { return m_position; }
+    inline int size() const { return m_size; }
+    inline int count() const { return m_size; }
+    inline int length() const { return m_size; }
+    inline QStringRef &operator=(const QStringRef &other) {
+        m_string = other.m_string; m_position = other.m_position;
+        m_size = other.m_size; return *this;
+    }
+    int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QStringRef &operator=(const QString *string);
+    inline const QChar *unicode() const {
+        if (!m_string)
+            return reinterpret_cast<const QChar *>(QString::shared_null.data);
+        return m_string->unicode() + m_position;
+    }
+    inline const QChar *data() const { return unicode(); }
+    inline const QChar *constData() const { return unicode(); }
+    QByteArray toAscii() const __attribute__ ((warn_unused_result));
+    QByteArray toLatin1() const __attribute__ ((warn_unused_result));
+    QByteArray toUtf8() const __attribute__ ((warn_unused_result));
+    QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result));
+    QVector<uint> toUcs4() const __attribute__ ((warn_unused_result));
+    inline void clear() { m_string = 0; m_position = m_size = 0; }
+    QString toString() const;
+    inline bool isEmpty() const { return m_size == 0; }
+    inline bool isNull() const { return m_string == 0 || m_string->isNull(); }
+    QStringRef appendTo(QString *string) const;
+    inline const QChar at(int i) const
+        { qt_noop(); return m_string->at(i + m_position); }
+    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    static int compare(const QStringRef &s1, const QString &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+    static int compare(const QStringRef &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+    static int compare(const QStringRef &s1, QLatin1String s2,
+                       Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    int localeAwareCompare(const QString &s) const;
+    int localeAwareCompare(const QStringRef &s) const;
+    static int localeAwareCompare(const QStringRef &s1, const QString &s2);
+    static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2);
+};
+inline QStringRef &QStringRef::operator=(const QString *aString)
+{ m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; }
+inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
+        :m_string(aString), m_position(aPosition), m_size(aSize){}
+inline QStringRef::QStringRef(const QString *aString)
+    :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}
+ bool operator==(const QStringRef &s1,const QStringRef &s2);
+inline bool operator!=(const QStringRef &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+ bool operator==(const QString &s1,const QStringRef &s2);
+inline bool operator!=(const QString &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1,const QString &s2)
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1,const QString &s2)
+{ return s2 != s1; }
+ bool operator==(const QLatin1String &s1, const QStringRef &s2);
+inline bool operator!=(const QLatin1String &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1,const QLatin1String &s2)
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1,const QLatin1String &s2)
+{ return s2 != s1; }
+ bool operator<(const QStringRef &s1,const QStringRef &s2);
+inline bool operator>(const QStringRef &s1, const QStringRef &s2)
+{ return s2 < s1; }
+inline bool operator<=(const QStringRef &s1, const QStringRef &s2)
+{ return !(s1 > s2); }
+inline bool operator>=(const QStringRef &s1, const QStringRef &s2)
+{ return !(s1 < s2); }
+inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2)
+{
+    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));
+    return (s1 == QLatin1String(s2));
+}
+inline bool operator==(const char *s1, const QStringRef &s2)
+{ return qStringComparisonHelper(s2, s1); }
+inline bool operator==(const QStringRef &s1, const char *s2)
+{ return qStringComparisonHelper(s1, s2); }
+inline bool operator!=(const char *s1, const QStringRef &s2)
+{ return !qStringComparisonHelper(s2, s1); }
+inline bool operator!=(const QStringRef &s1, const char *s2)
+{ return !qStringComparisonHelper(s1, s2); }
+inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s, cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }
+inline int QString::localeAwareCompare(const QStringRef &s) const
+{ return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
+{ return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+inline int QStringRef::localeAwareCompare(const QString &s) const
+{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s) const
+{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2)
+{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
+{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+inline QBool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(c, 0, cs) != -1); }
+inline QBool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class locale
+  {
+  public:
+    typedef int category;
+    class facet;
+    class id;
+    class _Impl;
+    friend class facet;
+    friend class _Impl;
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Cache>
+      friend struct __use_cache;
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+    locale() throw();
+    locale(const locale& __other) throw();
+    explicit
+    locale(const char* __s);
+    locale(const locale& __base, const char* __s, category __cat);
+    locale(const locale& __base, const locale& __add, category __cat);
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+    ~locale() throw();
+    const locale&
+    operator=(const locale& __other) throw();
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+    string
+    name() const;
+    bool
+    operator==(const locale& __other) const throw();
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+    static locale
+    global(const locale&);
+    static const locale&
+    classic();
+  private:
+    _Impl* _M_impl;
+    static _Impl* _S_classic;
+    static _Impl* _S_global;
+    static const char* const* const _S_categories;
+    enum { _S_categories_size = 6 + 6 };
+    static __gthread_once_t _S_once;
+    explicit
+    locale(_Impl*) throw();
+    static void
+    _S_initialize();
+    static void
+    _S_initialize_once() throw();
+    static category
+    _S_normalize_category(category);
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+  };
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+    mutable _Atomic_word _M_refcount;
+    static __c_locale _S_c_locale;
+    static const char _S_c_name[2];
+    static __gthread_once_t _S_once;
+    static void
+    _S_initialize_once();
+  protected:
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+    virtual
+    ~facet();
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+    static __c_locale
+    _S_get_c_locale();
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+    void
+    _M_remove_reference() const throw()
+    {
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+    facet(const facet&);
+    facet&
+    operator=(const facet&);
+  };
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    mutable size_t _M_index;
+    static _Atomic_word _S_refcount;
+    void
+    operator=(const id&);
+    id(const id&);
+  public:
+    id() { }
+    size_t
+    _M_id() const throw();
+  };
+  class locale::_Impl
+  {
+  public:
+    friend class locale;
+    friend class locale::facet;
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Cache>
+      friend struct __use_cache;
+  private:
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+    void
+    _M_remove_reference() throw()
+    {
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+   ~_Impl() throw();
+    _Impl(const _Impl&);
+    void
+    operator=(const _Impl&);
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+    void
+    _M_replace_categories(const _Impl*, category);
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+    void
+    _M_install_facet(const locale::id*, const facet*);
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+    void
+    _M_install_cache(const facet*, size_t);
+  };
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw();
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc);
+  template<typename _CharT>
+    class collate : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+    protected:
+      __c_locale _M_c_locale_collate;
+    public:
+      static locale::id id;
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+  protected:
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+  template<typename _CharT>
+    class collate_byname : public collate<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+    }
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+    }
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+   __p++;
+   __q++;
+ }
+    }
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+      const string_type __str(__lo, __hi);
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+      size_t __len = (__hi - __lo) * 2;
+      _CharT* __c = new _CharT[__len];
+      try
+ {
+   for (;;)
+     {
+       size_t __res = _M_transform(__c, __p, __len);
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+      delete [] __c;
+      return __ret;
+    }
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16
+    };
+  inline _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+  inline const _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Openmode
+    {
+      _S_app = 1L << 0,
+      _S_ate = 1L << 1,
+      _S_bin = 1L << 2,
+      _S_in = 1L << 3,
+      _S_out = 1L << 4,
+      _S_trunc = 1L << 5,
+      _S_ios_openmode_end = 1L << 16
+    };
+  inline _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+  inline const _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Iostate
+    {
+      _S_goodbit = 0,
+      _S_badbit = 1L << 0,
+      _S_eofbit = 1L << 1,
+      _S_failbit = 1L << 2,
+      _S_ios_iostate_end = 1L << 16
+    };
+  inline _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+  inline const _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Seekdir
+    {
+      _S_beg = 0,
+      _S_cur = 1,
+      _S_end = 2,
+      _S_ios_seekdir_end = 1L << 16
+    };
+  class ios_base
+  {
+  public:
+    class failure : public exception
+    {
+    public:
+      explicit
+      failure(const string& __str) throw();
+      virtual
+      ~failure() throw();
+      virtual const char*
+      what() const throw();
+    private:
+      string _M_msg;
+    };
+    typedef _Ios_Fmtflags fmtflags;
+    static const fmtflags boolalpha = _S_boolalpha;
+    static const fmtflags dec = _S_dec;
+    static const fmtflags fixed = _S_fixed;
+    static const fmtflags hex = _S_hex;
+    static const fmtflags internal = _S_internal;
+    static const fmtflags left = _S_left;
+    static const fmtflags oct = _S_oct;
+    static const fmtflags right = _S_right;
+    static const fmtflags scientific = _S_scientific;
+    static const fmtflags showbase = _S_showbase;
+    static const fmtflags showpoint = _S_showpoint;
+    static const fmtflags showpos = _S_showpos;
+    static const fmtflags skipws = _S_skipws;
+    static const fmtflags unitbuf = _S_unitbuf;
+    static const fmtflags uppercase = _S_uppercase;
+    static const fmtflags adjustfield = _S_adjustfield;
+    static const fmtflags basefield = _S_basefield;
+    static const fmtflags floatfield = _S_floatfield;
+    typedef _Ios_Iostate iostate;
+    static const iostate badbit = _S_badbit;
+    static const iostate eofbit = _S_eofbit;
+    static const iostate failbit = _S_failbit;
+    static const iostate goodbit = _S_goodbit;
+    typedef _Ios_Openmode openmode;
+    static const openmode app = _S_app;
+    static const openmode ate = _S_ate;
+    static const openmode binary = _S_bin;
+    static const openmode in = _S_in;
+    static const openmode out = _S_out;
+    static const openmode trunc = _S_trunc;
+    typedef _Ios_Seekdir seekdir;
+    static const seekdir beg = _S_beg;
+    static const seekdir cur = _S_cur;
+    static const seekdir end = _S_end;
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+    typedef void (*event_callback) (event, ios_base&, int);
+    void
+    register_callback(event_callback __fn, int __index);
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+    struct _Callback_list
+    {
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+      int
+      _M_remove_reference()
+      {
+        ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            ;
+          }
+        return __res;
+      }
+    };
+     _Callback_list* _M_callbacks;
+    void
+    _M_call_callbacks(event __ev) throw();
+    void
+    _M_dispose_callbacks(void) throw();
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+    _Words _M_word_zero;
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+    int _M_word_size;
+    _Words* _M_word;
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+    locale _M_ios_locale;
+    void
+    _M_init() throw();
+  public:
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+    fmtflags
+    flags() const
+    { return _M_flags; }
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+    streamsize
+    precision() const
+    { return _M_precision; }
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+    streamsize
+    width() const
+    { return _M_width; }
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+    static bool
+    sync_with_stdio(bool __sync = true);
+    locale
+    imbue(const locale& __loc) throw();
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+    static int
+    xalloc() throw();
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+    virtual ~ios_base();
+  protected:
+    ios_base() throw ();
+  private:
+    ios_base(const ios_base&);
+    ios_base&
+    operator=(const ios_base&);
+  };
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+      friend streamsize
+      __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+    protected:
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+      locale _M_buf_locale;
+  public:
+      virtual
+      ~basic_streambuf()
+      { }
+      locale
+      pubimbue(const locale &__loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+      __streambuf_type*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+      int
+      pubsync() { return this->sync(); }
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+    protected:
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+      char_type*
+      eback() const { return _M_in_beg; }
+      char_type*
+      gptr() const { return _M_in_cur; }
+      char_type*
+      egptr() const { return _M_in_end; }
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+      char_type*
+      pbase() const { return _M_out_beg; }
+      char_type*
+      pptr() const { return _M_out_cur; }
+      char_type*
+      epptr() const { return _M_out_end; }
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+      virtual void
+      imbue(const locale&)
+      { }
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+      virtual int
+      sync() { return 0; }
+      virtual streamsize
+      showmanyc() { return 0; }
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+      virtual int_type
+      pbackfail(int_type = traits_type::eof())
+      { return traits_type::eof(); }
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+      virtual int_type
+      overflow(int_type = traits_type::eof())
+      { return traits_type::eof(); }
+    public:
+      void
+      stossc()
+      {
+ if (this->gptr() < this->egptr())
+   this->gbump(1);
+ else
+   this->uflow();
+      }
+      void
+      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
+      void
+      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
+    private:
+      basic_streambuf(const __streambuf_type& __sb)
+      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
+      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
+      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
+      _M_buf_locale(__sb._M_buf_locale)
+      { }
+      __streambuf_type&
+      operator=(const __streambuf_type&) { return *this; };
+    };
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+     basic_streambuf<char>* __sbout, bool& __ineof);
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_gbump(__len);
+     }
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_pbump(__len);
+     }
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+}
+typedef unsigned long int wctype_t;
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+  _ISwupper = (1 << (__ISwupper)),
+  _ISwlower = (1 << (__ISwlower)),
+  _ISwalpha = (1 << (__ISwalpha)),
+  _ISwdigit = (1 << (__ISwdigit)),
+  _ISwxdigit = (1 << (__ISwxdigit)),
+  _ISwspace = (1 << (__ISwspace)),
+  _ISwprint = (1 << (__ISwprint)),
+  _ISwgraph = (1 << (__ISwgraph)),
+  _ISwblank = (1 << (__ISwblank)),
+  _ISwcntrl = (1 << (__ISwcntrl)),
+  _ISwpunct = (1 << (__ISwpunct)),
+  _ISwalnum = (1 << (__ISwalnum))
+};
+extern "C" {
+extern int iswalnum (wint_t __wc) throw ();
+extern int iswalpha (wint_t __wc) throw ();
+extern int iswcntrl (wint_t __wc) throw ();
+extern int iswdigit (wint_t __wc) throw ();
+extern int iswgraph (wint_t __wc) throw ();
+extern int iswlower (wint_t __wc) throw ();
+extern int iswprint (wint_t __wc) throw ();
+extern int iswpunct (wint_t __wc) throw ();
+extern int iswspace (wint_t __wc) throw ();
+extern int iswupper (wint_t __wc) throw ();
+extern int iswxdigit (wint_t __wc) throw ();
+extern int iswblank (wint_t __wc) throw ();
+extern wctype_t wctype (__const char *__property) throw ();
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+typedef __const __int32_t *wctrans_t;
+extern wint_t towlower (wint_t __wc) throw ();
+extern wint_t towupper (wint_t __wc) throw ();
+}
+extern "C" {
+extern wctrans_t wctrans (__const char *__property) throw ();
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
+extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
+extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
+     throw ();
+extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
+     throw ();
+extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
+extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
+extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale)
+     throw ();
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      __locale_t __locale) throw ();
+}
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+  using ::iswalnum;
+  using ::iswalpha;
+  using ::iswblank;
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  struct ctype_base
+  {
+    typedef const int* __to_type;
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+  };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+        _CharT*, _CharT&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename _Traits::int_type int_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+      template<bool _IsMove, typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+ __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+               istreambuf_iterator<_CharT2> >::__type
+ find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+    private:
+      mutable streambuf_type* _M_sbuf;
+      mutable int_type _M_c;
+    public:
+      istreambuf_iterator() throw()
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+      istreambuf_iterator(istream_type& __s) throw()
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+      istreambuf_iterator(streambuf_type* __s) throw()
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+      char_type
+      operator*() const
+      {
+ return traits_type::to_char_type(_M_get());
+      }
+      istreambuf_iterator&
+      operator++()
+      {
+                        ;
+ if (_M_sbuf)
+   {
+     _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return *this;
+      }
+      istreambuf_iterator
+      operator++(int)
+      {
+                        ;
+ istreambuf_iterator __old = *this;
+ if (_M_sbuf)
+   {
+     __old._M_c = _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return __old;
+      }
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+    private:
+      int_type
+      _M_get() const
+      {
+ const int_type __eof = traits_type::eof();
+ int_type __ret = __eof;
+ if (_M_sbuf)
+   {
+     if (!traits_type::eq_int_type(_M_c, __eof))
+       __ret = _M_c;
+     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
+            __eof))
+       _M_c = __ret;
+     else
+       _M_sbuf = 0;
+   }
+ return __ret;
+      }
+      bool
+      _M_at_eof() const
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(_M_get(), __eof);
+      }
+    };
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+    private:
+      streambuf_type* _M_sbuf;
+      bool _M_failed;
+    public:
+      ostreambuf_iterator(ostream_type& __s) throw ()
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+      ostreambuf_iterator(streambuf_type* __s) throw ()
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+ if (!_M_failed &&
+     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+   _M_failed = true;
+ return *this;
+      }
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+      bool
+      failed() const throw()
+      { return _M_failed; }
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+ if (__builtin_expect(!_M_failed, true)
+     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+    false))
+   _M_failed = true;
+ return *this;
+      }
+    };
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+                           ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last,
+  ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+ {
+   bool __ineof;
+   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+   if (!__ineof)
+     __result._M_failed = true;
+ }
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+     istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof()))
+     {
+       const streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    traits_type::copy(__result, __sb->gptr(), __n);
+    __sb->__safe_gbump(__n);
+    __result += __n;
+    __c = __sb->underflow();
+  }
+       else
+  {
+    *__result++ = traits_type::to_char_type(__c);
+    __c = __sb->snextc();
+  }
+     }
+ }
+      return __result;
+    }
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+          istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   const int_type __ival = traits_type::to_int_type(__val);
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof())
+   && !traits_type::eq_int_type(__c, __ival))
+     {
+       streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    const _CharT* __p = traits_type::find(__sb->gptr(),
+       __n, __val);
+    if (__p)
+      __n = __p - __sb->gptr();
+    __sb->__safe_gbump(__n);
+    __c = __sb->sgetc();
+  }
+       else
+  __c = __sb->snextc();
+     }
+   if (!traits_type::eq_int_type(__c, traits_type::eof()))
+     __first._M_c = __c;
+   else
+     __first._M_sbuf = 0;
+ }
+      return __first;
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+      typedef _CharT char_type;
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char *__to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+      virtual
+      ~__ctype_abstract_base() { }
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+      virtual char_type
+      do_toupper(char_type) const = 0;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+      virtual char_type
+      do_tolower(char_type) const = 0;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+      virtual char_type
+      do_widen(char) const = 0;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi,
+        char_type* __dest) const = 0;
+      virtual char
+      do_narrow(char_type, char __dfault) const = 0;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const = 0;
+    };
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+      static locale::id id;
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+   protected:
+      virtual
+      ~ctype();
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+      virtual char_type
+      do_toupper(char_type __c) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type __c) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char __c) const;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const;
+    };
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+      typedef char char_type;
+    protected:
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+    public:
+      static locale::id id;
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+      inline bool
+      is(mask __m, char __c) const;
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char *__to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+      const mask*
+      table() const throw()
+      { return _M_table; }
+      static const mask*
+      classic_table() throw();
+    protected:
+      virtual
+      ~ctype();
+      virtual char_type
+      do_toupper(char_type) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
+      {
+ __builtin_memcpy(__dest, __lo, __hi - __lo);
+ return __hi;
+      }
+      virtual char
+      do_narrow(char_type __c, char) const
+      { return __c; }
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char, char* __dest) const
+      {
+ __builtin_memcpy(__dest, __lo, __hi - __lo);
+ return __hi;
+      }
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+    protected:
+      __c_locale _M_c_locale_ctype;
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+    public:
+      static locale::id id;
+      explicit
+      ctype(size_t __refs = 0);
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+      virtual
+      ~ctype();
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+      virtual char_type
+      do_toupper(char_type) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char) const;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const;
+      void
+      _M_initialize_ctype() throw();
+    };
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~ctype_byname() { };
+    };
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  bool
+  ctype<char>::
+  is(mask __m, char __c) const
+  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
+  const char*
+  ctype<char>::
+  is(const char* __low, const char* __high, mask* __vec) const
+  {
+    while (__low < __high)
+      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
+    return __high;
+  }
+  const char*
+  ctype<char>::
+  scan_is(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
+      ++__low;
+    return __low;
+  }
+  const char*
+  ctype<char>::
+  scan_not(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
+      ++__low;
+    return __low;
+  }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class __num_base
+  {
+  public:
+    enum
+      {
+        _S_ominus,
+        _S_oplus,
+        _S_ox,
+        _S_oX,
+        _S_odigits,
+        _S_odigits_end = _S_odigits + 16,
+        _S_oudigits = _S_odigits_end,
+        _S_oudigits_end = _S_oudigits + 16,
+        _S_oe = _S_odigits + 14,
+        _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+    static const char* _S_atoms_out;
+    static const char* _S_atoms_in;
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      _CharT _M_atoms_out[__num_base::_S_oend];
+      _CharT _M_atoms_in[__num_base::_S_iend];
+      bool _M_allocated;
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+ _M_use_grouping(false),
+ _M_truename(0), _M_truename_size(0), _M_falsename(0),
+ _M_falsename_size(0), _M_decimal_point(_CharT()),
+ _M_thousands_sep(_CharT()), _M_allocated(false)
+        { }
+      ~__numpunct_cache();
+      void
+      _M_cache(const locale& __loc);
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+    protected:
+      __cache_type* _M_data;
+    public:
+      static locale::id id;
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+      string
+      grouping() const
+      { return this->do_grouping(); }
+      string_type
+      truename() const
+      { return this->do_truename(); }
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+    protected:
+      virtual
+      ~numpunct();
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+  template<>
+    numpunct<char>::~numpunct();
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+  template<>
+    numpunct<wchar_t>::~numpunct();
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      static locale::id id;
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+    protected:
+      virtual ~num_get() { }
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+      template<typename _ValueT>
+        iter_type
+        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+        _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+        {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+        _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+        {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      float&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      double&) const;
+      virtual iter_type
+      __do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+        double&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      void*&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      long double&) const;
+    };
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      static locale::id id;
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+    protected:
+      template<typename _ValueT>
+        iter_type
+        _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+      template<typename _ValueT>
+        iter_type
+        _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+      virtual
+      ~num_put() { };
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, double __v) const;
+      virtual iter_type
+      __do_put(iter_type, ios_base&, char_type __fill, double __v) const;
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
+    };
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+}
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = 0;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   _M_grouping_size = __np.grouping().size();
+   __grouping = new char[_M_grouping_size];
+   __np.grouping().copy(__grouping, _M_grouping_size);
+   _M_grouping = __grouping;
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(_M_grouping[0]) > 0
+        && (_M_grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+   _M_truename_size = __np.truename().size();
+   __truename = new _CharT[_M_truename_size];
+   __np.truename().copy(__truename, _M_truename_size);
+   _M_truename = __truename;
+   _M_falsename_size = __np.falsename().size();
+   __falsename = new _CharT[_M_falsename_size];
+   __np.falsename().copy(__falsename, _M_falsename_size);
+   _M_falsename = __falsename;
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+      bool __testeof = __beg == __end;
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+      if (!__lc->_M_allocated)
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+  __xtrc += 'e';
+  __found_sci = true;
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<char>(__sep_pos);
+   __sep_pos = 0;
+        }
+      else
+        {
+   __xtrc.clear();
+   break;
+        }
+    }
+  else
+    break;
+       }
+     else if (__c == __lc->_M_decimal_point)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+      if (__found_grouping.size())
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += '.';
+      __found_dec = true;
+    }
+  else
+    break;
+       }
+     else
+       {
+  const char_type* __q =
+    __traits_type::find(__lit_zero, 10, __c);
+  if (__q)
+    {
+      __xtrc += '0' + (__q - __lit_zero);
+      __found_mantissa = true;
+      ++__sep_pos;
+    }
+  else if ((__c == __lit[__num_base::_S_ie]
+     || __c == __lit[__num_base::_S_iE])
+    && !__found_sci && __found_mantissa)
+    {
+      if (__found_grouping.size() && !__found_dec)
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += 'e';
+      __found_sci = true;
+      if (++__beg != __end)
+        {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping
+     && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+        __xtrc += __plus ? '+' : '-';
+   else
+     continue;
+        }
+      else
+        {
+   __testeof = true;
+   break;
+        }
+    }
+  else
+    break;
+       }
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      if (__found_grouping.size())
+        {
+   if (!__found_dec && !__found_sci)
+     __found_grouping += static_cast<char>(__sep_pos);
+          if (!std::__verify_grouping(__lc->_M_grouping,
+          __lc->_M_grouping_size,
+          __found_grouping))
+     __err = ios_base::failbit;
+        }
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+ bool __testeof = __beg == __end;
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
+   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+ if (!__lc->_M_allocated)
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ if (__found_grouping.size())
+   {
+     __found_grouping += static_cast<char>(__sep_pos);
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative
+  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
+     else
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+       const char_type __c = *__beg;
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+       if (!__testf && __donet)
+  break;
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+       if (!__testt && __donef)
+  break;
+       if (!__testt && !__testf)
+  break;
+       ++__n;
+       ++__beg;
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    __do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+      __io.flags(__fmt);
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+}
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+ if (__lc->_M_use_grouping)
+   {
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+ if (__builtin_expect(__dec, true))
+   {
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+ return std::__write(__s, __cs, __len);
+      }
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+ int __len;
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+          __fbuf, __prec, __v);
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+       __fbuf, __prec, __v);
+   }
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+     __ws = __ws2;
+   }
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+ return std::__write(__s, __ws, __len);
+      }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    __do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+}
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+      while (__first != __last)
+ *__s++ = *__first++;
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+      return __s;
+    }
+  extern template class numpunct<char>;
+  extern template class numpunct_byname<char>;
+  extern template class __gnu_cxx_ldbl128:: num_get<char>;
+  extern template class __gnu_cxx_ldbl128:: num_put<char>;
+  extern template class ctype_byname<char>;
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+  extern template class numpunct<wchar_t>;
+  extern template class numpunct_byname<wchar_t>;
+  extern template class __gnu_cxx_ldbl128:: num_get<wchar_t>;
+  extern template class __gnu_cxx_ldbl128:: num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+    protected:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+      const __ctype_type* _M_ctype;
+      const __num_put_type* _M_num_put;
+      const __num_get_type* _M_num_get;
+    public:
+      operator void*() const
+      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
+      bool
+      operator!() const
+      { return this->fail(); }
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+      void
+      clear(iostate __state = goodbit);
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+      void
+      _M_setstate(iostate __state)
+      {
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+      iostate
+      exceptions() const
+      { return _M_exception; }
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+      virtual
+      ~basic_ios() { }
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+      locale
+      imbue(const locale& __loc);
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+    protected:
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+      if (this != &__rhs)
+ {
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+   _M_call_callbacks(copyfmt_event);
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      ios_base::_M_init();
+      _M_cache_locale(_M_ios_locale);
+      _M_fill = _CharT();
+      _M_fill_init = false;
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = &use_facet<__ctype_type>(__loc);
+      else
+ _M_ctype = 0;
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = &use_facet<__num_put_type>(__loc);
+      else
+ _M_num_put = 0;
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = &use_facet<__num_get_type>(__loc);
+      else
+ _M_num_get = 0;
+    }
+  extern template class basic_ios<char>;
+  extern template class basic_ios<wchar_t>;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+      virtual
+      ~basic_ostream() { }
+      class sentry;
+      friend class sentry;
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+ return __pf(*this);
+      }
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(short __n);
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+      __ostream_type&
+      operator<<(int __n);
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+      __ostream_type&
+      operator<<(float __f)
+      {
+ return _M_insert(static_cast<double>(__f));
+      }
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+      __ostream_type&
+      put(char_type __c);
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+      __ostream_type&
+      flush();
+      pos_type
+      tellp();
+      __ostream_type&
+      seekp(pos_type);
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+    protected:
+      basic_ostream()
+      { this->init(0); }
+      template<typename _ValueT>
+        __ostream_type&
+        _M_insert(_ValueT __v);
+    };
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+    public:
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+      ~sentry()
+      {
+ if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+   {
+     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+       _M_os.setstate(ios_base::badbit);
+   }
+      }
+      operator bool() const
+      { return _M_ok; }
+    };
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+  template <class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+    protected:
+      streamsize _M_gcount;
+    public:
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+      class sentry;
+      friend class sentry;
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(short& __n);
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(int& __n);
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+      int_type
+      get();
+      __istream_type&
+      get(char_type& __c);
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+      __istream_type&
+      ignore();
+      __istream_type&
+      ignore(streamsize __n);
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+      int_type
+      peek();
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+      __istream_type&
+      putback(char_type __c);
+      __istream_type&
+      unget();
+      int
+      sync();
+      pos_type
+      tellg();
+      __istream_type&
+      seekg(pos_type);
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+      template<typename _ValueT>
+        __istream_type&
+        _M_extract(_ValueT& __v);
+    };
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+      bool _M_ok;
+    public:
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+      operator bool() const
+      { return _M_ok; }
+    };
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+      virtual
+      ~basic_iostream() { }
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+    };
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ {
+   if (__in.tie())
+     __in.tie()->flush();
+   if (!__noskip && bool(__in.flags() & ios_base::skipws))
+     {
+       const __int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       __int_type __c = __sb->sgetc();
+       const __ctype_type& __ct = __check_facet(__in._M_ctype);
+       while (!traits_type::eq_int_type(__c, __eof)
+       && __ct.is(ctype_base::space,
+    traits_type::to_char_type(__c)))
+  __c = __sb->snextc();
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+ }
+      if (__in.good() && __err == ios_base::goodbit)
+ _M_ok = true;
+      else
+ {
+   __err |= ios_base::failbit;
+   __in.setstate(__err);
+ }
+    }
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+ sentry __cerb(*this, false);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_get_type& __ng = __check_facet(this->_M_num_get);
+  __ng.get(*this, 0, *this, __err, __v);
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__max;
+  }
+       else
+  __n = short(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__max;
+  }
+       else
+  __n = int(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+ {
+   try
+     {
+       bool __ineof;
+       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+  __err |= ios_base::failbit;
+       if (__ineof)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::failbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbout)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       __c = this->rdbuf()->sbumpc();
+       if (!traits_type::eq_int_type(__c, __eof))
+  _M_gcount = 1;
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return __c;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __cb = this->rdbuf()->sbumpc();
+       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+  {
+    _M_gcount = 1;
+    __c = traits_type::to_char_type(__cb);
+  }
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       int_type __c = __sb->sgetc();
+       while (_M_gcount + 1 < __n
+       && !traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim))
+  {
+    *__s++ = traits_type::to_char_type(__c);
+    ++_M_gcount;
+    __c = __sb->snextc();
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __this_sb = this->rdbuf();
+       int_type __c = __this_sb->sgetc();
+       char_type __c2 = traits_type::to_char_type(__c);
+       while (!traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim)
+       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+  {
+    ++_M_gcount;
+    __c = __this_sb->snextc();
+    __c2 = traits_type::to_char_type(__c);
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+  __err |= ios_base::eofbit;
+       else
+  _M_gcount = 1;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+      _M_gcount = 0;
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+      _M_gcount = 0;
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       if (!this->fail())
+  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+        ios_base::in);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+         ios_base::in);
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+         ios_base::in);
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+  extern template class basic_iostream<char>;
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+  extern template class basic_iostream<wchar_t>;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+    private:
+      istream_type* _M_stream;
+      _Tp _M_value;
+      bool _M_ok;
+    public:
+      istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+      istream_iterator(istream_type& __s)
+      : _M_stream(&__s)
+      { _M_read(); }
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+      const _Tp&
+      operator*() const
+      {
+                        ;
+ return _M_value;
+      }
+      const _Tp*
+      operator->() const { return &(operator*()); }
+      istream_iterator&
+      operator++()
+      {
+                        ;
+ _M_read();
+ return *this;
+      }
+      istream_iterator
+      operator++(int)
+      {
+                        ;
+ istream_iterator __tmp = *this;
+ _M_read();
+ return __tmp;
+      }
+      bool
+      _M_equal(const istream_iterator& __x) const
+      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
+    private:
+      void
+      _M_read()
+      {
+ _M_ok = (_M_stream && *_M_stream) ? true : false;
+ if (_M_ok)
+   {
+     *_M_stream >> _M_value;
+     _M_ok = *_M_stream ? true : false;
+   }
+      }
+    };
+  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
+    inline bool
+    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return __x._M_equal(__y); }
+  template <class _Tp, class _CharT, class _Traits, class _Dist>
+    inline bool
+    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return !__x._M_equal(__y); }
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+    private:
+      ostream_type* _M_stream;
+      const _CharT* _M_string;
+    public:
+      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(&__s), _M_string(__c) { }
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
+      ostream_iterator&
+      operator=(const _Tp& __value)
+      {
+                        ;
+ *_M_stream << __value;
+ if (_M_string) *_M_stream << _M_string;
+ return *this;
+      }
+      ostream_iterator&
+      operator*()
+      { return *this; }
+      ostream_iterator&
+      operator++()
+      { return *this; }
+      ostream_iterator&
+      operator++(int)
+      { return *this; }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  namespace __detail
+  {
+    struct _List_node_base
+    {
+      _List_node_base* _M_next;
+      _List_node_base* _M_prev;
+      static void
+      swap(_List_node_base& __x, _List_node_base& __y) throw ();
+      void
+      _M_transfer(_List_node_base* const __first,
+    _List_node_base* const __last) throw ();
+      void
+      _M_reverse() throw ();
+      void
+      _M_hook(_List_node_base* const __position) throw ();
+      void
+      _M_unhook() throw ();
+    };
+  }
+  template<typename _Tp>
+    struct _List_node : public __detail::_List_node_base
+    {
+      _Tp _M_data;
+    };
+  template<typename _Tp>
+    struct _List_iterator
+    {
+      typedef _List_iterator<_Tp> _Self;
+      typedef _List_node<_Tp> _Node;
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+      _List_iterator()
+      : _M_node() { }
+      explicit
+      _List_iterator(__detail::_List_node_base* __x)
+      : _M_node(__x) { }
+      reference
+      operator*() const
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+      pointer
+      operator->() const
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+      _Self&
+      operator++()
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+      _Self&
+      operator--()
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+      __detail::_List_node_base* _M_node;
+    };
+  template<typename _Tp>
+    struct _List_const_iterator
+    {
+      typedef _List_const_iterator<_Tp> _Self;
+      typedef const _List_node<_Tp> _Node;
+      typedef _List_iterator<_Tp> iterator;
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+      _List_const_iterator()
+      : _M_node() { }
+      explicit
+      _List_const_iterator(const __detail::_List_node_base* __x)
+      : _M_node(__x) { }
+      _List_const_iterator(const iterator& __x)
+      : _M_node(__x._M_node) { }
+      reference
+      operator*() const
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+      pointer
+      operator->() const
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+      _Self&
+      operator++()
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+      _Self&
+      operator--()
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+      const __detail::_List_node_base* _M_node;
+    };
+  template<typename _Val>
+    inline bool
+    operator==(const _List_iterator<_Val>& __x,
+        const _List_const_iterator<_Val>& __y)
+    { return __x._M_node == __y._M_node; }
+  template<typename _Val>
+    inline bool
+    operator!=(const _List_iterator<_Val>& __x,
+               const _List_const_iterator<_Val>& __y)
+    { return __x._M_node != __y._M_node; }
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    protected:
+      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
+        _Node_alloc_type;
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+      struct _List_impl
+      : public _Node_alloc_type
+      {
+ __detail::_List_node_base _M_node;
+ _List_impl()
+ : _Node_alloc_type(), _M_node()
+ { }
+ _List_impl(const _Node_alloc_type& __a)
+ : _Node_alloc_type(__a), _M_node()
+ { }
+      };
+      _List_impl _M_impl;
+      _List_node<_Tp>*
+      _M_get_node()
+      { return _M_impl._Node_alloc_type::allocate(1); }
+      void
+      _M_put_node(_List_node<_Tp>* __p)
+      { _M_impl._Node_alloc_type::deallocate(__p, 1); }
+  public:
+      typedef _Alloc allocator_type;
+      _Node_alloc_type&
+      _M_get_Node_allocator()
+      { return *static_cast<_Node_alloc_type*>(&this->_M_impl); }
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const
+      { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }
+      _Tp_alloc_type
+      _M_get_Tp_allocator() const
+      { return _Tp_alloc_type(_M_get_Node_allocator()); }
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Node_allocator()); }
+      _List_base()
+      : _M_impl()
+      { _M_init(); }
+      _List_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_init(); }
+      ~_List_base()
+      { _M_clear(); }
+      void
+      _M_clear();
+      void
+      _M_init()
+      {
+        this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
+        this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
+      }
+    };
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class list : protected _List_base<_Tp, _Alloc>
+    {
+      typedef typename _Alloc::value_type _Alloc_value_type;
+      typedef _List_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_type::pointer pointer;
+      typedef typename _Tp_alloc_type::const_pointer const_pointer;
+      typedef typename _Tp_alloc_type::reference reference;
+      typedef typename _Tp_alloc_type::const_reference const_reference;
+      typedef _List_iterator<_Tp> iterator;
+      typedef _List_const_iterator<_Tp> const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+    protected:
+      typedef _List_node<_Tp> _Node;
+      using _Base::_M_impl;
+      using _Base::_M_put_node;
+      using _Base::_M_get_node;
+      using _Base::_M_get_Tp_allocator;
+      using _Base::_M_get_Node_allocator;
+      _Node*
+      _M_create_node(const value_type& __x)
+      {
+ _Node* __p = this->_M_get_node();
+ try
+   {
+     _M_get_Tp_allocator().construct
+       (std::__addressof(__p->_M_data), __x);
+   }
+ catch(...)
+   {
+     _M_put_node(__p);
+     throw;
+   }
+ return __p;
+      }
+    public:
+      list()
+      : _Base() { }
+      explicit
+      list(const allocator_type& __a)
+      : _Base(__a) { }
+      explicit
+      list(size_type __n, const value_type& __value = value_type(),
+    const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      { _M_fill_initialize(__n, __value); }
+      list(const list& __x)
+      : _Base(__x._M_get_Node_allocator())
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+      template<typename _InputIterator>
+        list(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+        : _Base(__a)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_initialize_dispatch(__first, __last, _Integral());
+ }
+      list&
+      operator=(const list& __x);
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_assign_dispatch(__first, __last, _Integral());
+ }
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+      iterator
+      begin()
+      { return iterator(this->_M_impl._M_node._M_next); }
+      const_iterator
+      begin() const
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+      iterator
+      end()
+      { return iterator(&this->_M_impl._M_node); }
+      const_iterator
+      end() const
+      { return const_iterator(&this->_M_impl._M_node); }
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+      bool
+      empty() const
+      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
+      size_type
+      size() const
+      { return std::distance(begin(), end()); }
+      size_type
+      max_size() const
+      { return _M_get_Node_allocator().max_size(); }
+      void
+      resize(size_type __new_size, value_type __x = value_type());
+      reference
+      front()
+      { return *begin(); }
+      const_reference
+      front() const
+      { return *begin(); }
+      reference
+      back()
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+      const_reference
+      back() const
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+      void
+      push_front(const value_type& __x)
+      { this->_M_insert(begin(), __x); }
+      void
+      pop_front()
+      { this->_M_erase(begin()); }
+      void
+      push_back(const value_type& __x)
+      { this->_M_insert(end(), __x); }
+      void
+      pop_back()
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+      iterator
+      insert(iterator __position, const value_type& __x);
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      {
+ list __tmp(__n, __x, _M_get_Node_allocator());
+ splice(__position, __tmp);
+      }
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   list __tmp(__first, __last, _M_get_Node_allocator());
+   splice(__position, __tmp);
+ }
+      iterator
+      erase(iterator __position);
+      iterator
+      erase(iterator __first, iterator __last)
+      {
+ while (__first != __last)
+   __first = erase(__first);
+ return __last;
+      }
+      void
+      swap(list& __x)
+      {
+ __detail::_List_node_base::swap(this->_M_impl._M_node,
+     __x._M_impl._M_node);
+ std::__alloc_swap<typename _Base::_Node_alloc_type>::
+   _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
+      }
+      void
+      clear()
+      {
+        _Base::_M_clear();
+        _Base::_M_init();
+      }
+      void
+      splice(iterator __position, list& __x)
+      {
+ if (!__x.empty())
+   {
+     _M_check_equal_allocators(__x);
+     this->_M_transfer(__position, __x.begin(), __x.end());
+   }
+      }
+      void
+      splice(iterator __position, list& __x, iterator __i)
+      {
+ iterator __j = __i;
+ ++__j;
+ if (__position == __i || __position == __j)
+   return;
+ if (this != &__x)
+   _M_check_equal_allocators(__x);
+ this->_M_transfer(__position, __i, __j);
+      }
+      void
+      splice(iterator __position, list& __x, iterator __first,
+      iterator __last)
+      {
+ if (__first != __last)
+   {
+     if (this != &__x)
+       _M_check_equal_allocators(__x);
+     this->_M_transfer(__position, __first, __last);
+   }
+      }
+      void
+      remove(const _Tp& __value);
+      template<typename _Predicate>
+        void
+        remove_if(_Predicate);
+      void
+      unique();
+      template<typename _BinaryPredicate>
+        void
+        unique(_BinaryPredicate);
+      void
+      merge(list& __x);
+      template<typename _StrictWeakOrdering>
+        void
+        merge(list&, _StrictWeakOrdering);
+      void
+      reverse()
+      { this->_M_impl._M_node._M_reverse(); }
+      void
+      sort();
+      template<typename _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering);
+    protected:
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+      void
+      _M_fill_initialize(size_type __n, const value_type& __x)
+      {
+ for (; __n; --__n)
+   push_back(__x);
+      }
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type);
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+      void
+      _M_transfer(iterator __position, iterator __first, iterator __last)
+      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
+      void
+      _M_insert(iterator __position, const value_type& __x)
+      {
+        _Node* __tmp = _M_create_node(__x);
+        __tmp->_M_hook(__position._M_node);
+      }
+      void
+      _M_erase(iterator __position)
+      {
+        __position._M_node->_M_unhook();
+        _Node* __n = static_cast<_Node*>(__position._M_node);
+ _M_get_Tp_allocator().destroy(std::__addressof(__n->_M_data));
+        _M_put_node(__n);
+      }
+      void
+      _M_check_equal_allocators(list& __x)
+      {
+ if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
+     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
+   __throw_runtime_error(("list::_M_check_equal_allocators"));
+      }
+    };
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = __x.end();
+      const_iterator __end2 = __y.end();
+      const_iterator __i1 = __x.begin();
+      const_iterator __i2 = __y.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+ {
+   ++__i1;
+   ++__i2;
+ }
+      return __i1 == __end1 && __i2 == __end2;
+    }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp, typename _Alloc>
+    void
+    _List_base<_Tp, _Alloc>::
+    _M_clear()
+    {
+      typedef _List_node<_Tp> _Node;
+      _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
+      while (__cur != &this->_M_impl._M_node)
+ {
+   _Node* __tmp = __cur;
+   __cur = static_cast<_Node*>(__cur->_M_next);
+   _M_get_Tp_allocator().destroy(std::__addressof(__tmp->_M_data));
+   _M_put_node(__tmp);
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    insert(iterator __position, const value_type& __x)
+    {
+      _Node* __tmp = _M_create_node(__x);
+      __tmp->_M_hook(__position._M_node);
+      return iterator(__tmp);
+    }
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    erase(iterator __position)
+    {
+      iterator __ret = iterator(__position._M_node->_M_next);
+      _M_erase(__position);
+      return __ret;
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, value_type __x)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else
+        insert(end(), __new_size - __len, __x);
+    }
+  template<typename _Tp, typename _Alloc>
+    list<_Tp, _Alloc>&
+    list<_Tp, _Alloc>::
+    operator=(const list& __x)
+    {
+      if (this != &__x)
+ {
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   const_iterator __first2 = __x.begin();
+   const_iterator __last2 = __x.end();
+   for (; __first1 != __last1 && __first2 != __last2;
+        ++__first1, ++__first2)
+     *__first1 = *__first2;
+   if (__first2 == __last2)
+     erase(__first1, __last1);
+   else
+     insert(__last1, __first2, __last2);
+ }
+      return *this;
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_fill_assign(size_type __n, const value_type& __val)
+    {
+      iterator __i = begin();
+      for (; __i != end() && __n > 0; ++__i, --__n)
+        *__i = __val;
+      if (__n > 0)
+        insert(end(), __n, __val);
+      else
+        erase(__i, end());
+    }
+  template<typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      list<_Tp, _Alloc>::
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
+    __false_type)
+      {
+        iterator __first1 = begin();
+        iterator __last1 = end();
+        for (; __first1 != __last1 && __first2 != __last2;
+      ++__first1, ++__first2)
+          *__first1 = *__first2;
+        if (__first2 == __last2)
+          erase(__first1, __last1);
+        else
+          insert(__last1, __first2, __last2);
+      }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    remove(const value_type& __value)
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      iterator __extra = __last;
+      while (__first != __last)
+ {
+   iterator __next = __first;
+   ++__next;
+   if (*__first == __value)
+     {
+       if (std::__addressof(*__first) != std::__addressof(__value))
+  _M_erase(__first);
+       else
+  __extra = __first;
+     }
+   __first = __next;
+ }
+      if (__extra != __last)
+ _M_erase(__extra);
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    unique()
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      if (__first == __last)
+ return;
+      iterator __next = __first;
+      while (++__next != __last)
+ {
+   if (*__first == *__next)
+     _M_erase(__next);
+   else
+     __first = __next;
+   __next = __first;
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    merge(list& __x)
+    {
+      if (this != &__x)
+ {
+   _M_check_equal_allocators(__x);
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   iterator __first2 = __x.begin();
+   iterator __last2 = __x.end();
+   while (__first1 != __last1 && __first2 != __last2)
+     if (*__first2 < *__first1)
+       {
+  iterator __next = __first2;
+  _M_transfer(__first1, __first2, ++__next);
+  __first2 = __next;
+       }
+     else
+       ++__first1;
+   if (__first2 != __last2)
+     _M_transfer(__last1, __first2, __last2);
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+      merge(list& __x, _StrictWeakOrdering __comp)
+      {
+ if (this != &__x)
+   {
+     _M_check_equal_allocators(__x);
+     iterator __first1 = begin();
+     iterator __last1 = end();
+     iterator __first2 = __x.begin();
+     iterator __last2 = __x.end();
+     while (__first1 != __last1 && __first2 != __last2)
+       if (__comp(*__first2, *__first1))
+  {
+    iterator __next = __first2;
+    _M_transfer(__first1, __first2, ++__next);
+    __first2 = __next;
+  }
+       else
+  ++__first1;
+     if (__first2 != __last2)
+       _M_transfer(__last1, __first2, __last2);
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    sort()
+    {
+      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+      {
+        list __carry;
+        list __tmp[64];
+        list * __fill = &__tmp[0];
+        list * __counter;
+        do
+   {
+     __carry.splice(__carry.begin(), *this, begin());
+     for(__counter = &__tmp[0];
+  __counter != __fill && !__counter->empty();
+  ++__counter)
+       {
+  __counter->merge(__carry);
+  __carry.swap(*__counter);
+       }
+     __carry.swap(*__counter);
+     if (__counter == __fill)
+       ++__fill;
+   }
+ while ( !empty() );
+        for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+          __counter->merge(*(__counter - 1));
+        swap( *(__fill - 1) );
+      }
+    }
+  template<typename _Tp, typename _Alloc>
+    template <typename _Predicate>
+      void
+      list<_Tp, _Alloc>::
+      remove_if(_Predicate __pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        while (__first != __last)
+   {
+     iterator __next = __first;
+     ++__next;
+     if (__pred(*__first))
+       _M_erase(__first);
+     __first = __next;
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    template <typename _BinaryPredicate>
+      void
+      list<_Tp, _Alloc>::
+      unique(_BinaryPredicate __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+   return;
+        iterator __next = __first;
+        while (++__next != __last)
+   {
+     if (__binary_pred(*__first, *__next))
+       _M_erase(__next);
+     else
+       __first = __next;
+     __next = __first;
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+      sort(_StrictWeakOrdering __comp)
+      {
+ if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+   {
+     list __carry;
+     list __tmp[64];
+     list * __fill = &__tmp[0];
+     list * __counter;
+     do
+       {
+  __carry.splice(__carry.begin(), *this, begin());
+  for(__counter = &__tmp[0];
+      __counter != __fill && !__counter->empty();
+      ++__counter)
+    {
+      __counter->merge(__carry, __comp);
+      __carry.swap(*__counter);
+    }
+  __carry.swap(*__counter);
+  if (__counter == __fill)
+    ++__fill;
+       }
+     while ( !empty() );
+     for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+       __counter->merge(*(__counter - 1), __comp);
+     swap(*(__fill - 1));
+   }
+      }
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T> class QVector;
+template <typename T> class QSet;
+struct QListData {
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, begin, end;
+        uint sharable : 1;
+        void *array[1];
+    };
+    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };
+    Data *detach(int alloc);
+    Data *detach_grow(int *i, int n);
+    Data *detach();
+    Data *detach2();
+    Data *detach3();
+    void realloc(int alloc);
+    static Data shared_null;
+    Data *d;
+    void **erase(void **xi);
+    void **append(int n);
+    void **append();
+    void **append(const QListData &l);
+    void **append2(const QListData &l);
+    void **prepend();
+    void **insert(int i);
+    void remove(int i);
+    void remove(int i, int n);
+    void move(int from, int to);
+    inline int size() const { return d->end - d->begin; }
+    inline bool isEmpty() const { return d->end == d->begin; }
+    inline void **at(int i) const { return d->array + d->begin + i; }
+    inline void **begin() const { return d->array + d->begin; }
+    inline void **end() const { return d->array + d->end; }
+};
+template <typename T>
+class QList
+{
+    struct Node { void *v;
+        inline T &t()
+        { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
+                                       ? v : this); }
+    };
+    union { QListData p; QListData::Data *d; };
+public:
+    inline QList() : d(&QListData::shared_null) { d->ref.ref(); }
+    inline QList(const QList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+    ~QList();
+    QList<T> &operator=(const QList<T> &l);
+    inline void swap(QList<T> &other) { qSwap(d, other.d); }
+    bool operator==(const QList<T> &l) const;
+    inline bool operator!=(const QList<T> &l) const { return !(*this == l); }
+    inline int size() const { return p.size(); }
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline void detachShared()
+    {
+        if (d->ref != 1 && this->d != &QListData::shared_null)
+            detach_helper();
+    }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline bool isSharedWith(const QList<T> &other) const { return d == other.d; }
+    inline bool isEmpty() const { return p.isEmpty(); }
+    void clear();
+    const T &at(int i) const;
+    const T &operator[](int i) const;
+    T &operator[](int i);
+    void reserve(int size);
+    void append(const T &t);
+    void append(const QList<T> &t);
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void replace(int i, const T &t);
+    void removeAt(int i);
+    int removeAll(const T &t);
+    bool removeOne(const T &t);
+    T takeAt(int i);
+    T takeFirst();
+    T takeLast();
+    void move(int from, int to);
+    void swap(int i, int j);
+    int indexOf(const T &t, int from = 0) const;
+    int lastIndexOf(const T &t, int from = -1) const;
+    QBool contains(const T &t) const;
+    int count(const T &t) const;
+    class const_iterator;
+    class iterator {
+    public:
+        Node *i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+        inline iterator() : i(0) {}
+        inline iterator(Node *n) : i(n) {}
+        inline iterator(const iterator &o): i(o.i){}
+        inline T &operator*() const { return i->t(); }
+        inline T *operator->() const { return &i->t(); }
+        inline T &operator[](int j) const { return i[j].t(); }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator<(const iterator& other) const { return i < other.i; }
+        inline bool operator<=(const iterator& other) const { return i <= other.i; }
+        inline bool operator>(const iterator& other) const { return i > other.i; }
+        inline bool operator>=(const iterator& other) const { return i >= other.i; }
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const
+            { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const
+            { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const
+            { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const
+            { return i >= other.i; }
+        inline iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { Node *n = i; ++i; return n; }
+        inline iterator &operator--() { i--; return *this; }
+        inline iterator operator--(int) { Node *n = i; i--; return n; }
+        inline iterator &operator+=(int j) { i+=j; return *this; }
+        inline iterator &operator-=(int j) { i-=j; return *this; }
+        inline iterator operator+(int j) const { return iterator(i+j); }
+        inline iterator operator-(int j) const { return iterator(i-j); }
+        inline int operator-(iterator j) const { return int(i - j.i); }
+    };
+    friend class iterator;
+    class const_iterator {
+    public:
+        Node *i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline const_iterator() : i(0) {}
+        inline const_iterator(Node *n) : i(n) {}
+        inline const_iterator(const const_iterator &o): i(o.i) {}
+        inline const_iterator(const iterator &o): i(o.i) {}
+        inline const T &operator*() const { return i->t(); }
+        inline const T *operator->() const { return &i->t(); }
+        inline const T &operator[](int j) const { return i[j].t(); }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
+        inline const_iterator &operator++() { ++i; return *this; }
+        inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
+        inline const_iterator &operator--() { i--; return *this; }
+        inline const_iterator operator--(int) { Node *n = i; i--; return n; }
+        inline const_iterator &operator+=(int j) { i+=j; return *this; }
+        inline const_iterator &operator-=(int j) { i-=j; return *this; }
+        inline const_iterator operator+(int j) const { return const_iterator(i+j); }
+        inline const_iterator operator-(int j) const { return const_iterator(i-j); }
+        inline int operator-(const_iterator j) const { return i - j.i; }
+    };
+    friend class const_iterator;
+    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
+    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); }
+    iterator insert(iterator before, const T &t);
+    iterator erase(iterator pos);
+    iterator erase(iterator first, iterator last);
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return p.size(); }
+    inline int length() const { return p.size(); }
+    inline T& first() { qt_noop(); return *begin(); }
+    inline const T& first() const { qt_noop(); return at(0); }
+    T& last() { qt_noop(); return *(--end()); }
+    const T& last() const { qt_noop(); return at(count() - 1); }
+    inline void removeFirst() { qt_noop(); erase(begin()); }
+    inline void removeLast() { qt_noop(); erase(--end()); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    QList<T> mid(int pos, int length = -1) const;
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    inline T& front() { return first(); }
+    inline const T& front() const { return first(); }
+    inline T& back() { return last(); }
+    inline const T& back() const { return last(); }
+    inline void pop_front() { removeFirst(); }
+    inline void pop_back() { removeLast(); }
+    inline bool empty() const { return isEmpty(); }
+    typedef int size_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    QList<T> &operator+=(const QList<T> &l);
+    inline QList<T> operator+(const QList<T> &l) const
+    { QList n = *this; n += l; return n; }
+    inline QList<T> &operator+=(const T &t)
+    { append(t); return *this; }
+    inline QList<T> &operator<< (const T &t)
+    { append(t); return *this; }
+    inline QList<T> &operator<<(const QList<T> &l)
+    { *this += l; return *this; }
+    QVector<T> toVector() const;
+    QSet<T> toSet() const;
+    static QList<T> fromVector(const QVector<T> &vector);
+    static QList<T> fromSet(const QSet<T> &set);
+    static inline QList<T> fromStdList(const std::list<T> &list)
+    { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::list<T> toStdList() const
+    { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
+private:
+    Node *detach_helper_grow(int i, int n);
+    void detach_helper(int alloc);
+    void detach_helper();
+    void free(QListData::Data *d);
+    void node_construct(Node *n, const T &t);
+    void node_destruct(Node *n);
+    void node_copy(Node *from, Node *to, Node *src);
+    void node_destruct(Node *from, Node *to);
+};
+template <typename T>
+inline void QList<T>::node_construct(Node *n, const T &t)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
+    else if (QTypeInfo<T>::isComplex) new (n) T(t);
+    else ::memcpy(n, &t, sizeof(T));
+}
+template <typename T>
+inline void QList<T>::node_destruct(Node *n)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
+    else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
+}
+template <typename T>
+inline void QList<T>::node_copy(Node *from, Node *to, Node *src)
+{
+    Node *current = from;
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        try {
+            while(current != to) {
+                current->v = new T(*reinterpret_cast<T*>(src->v));
+                ++current;
+                ++src;
+            }
+        } catch (...) {
+            while (current-- != from)
+                delete reinterpret_cast<T*>(current->v);
+            throw;
+        }
+    } else if (QTypeInfo<T>::isComplex) {
+        try {
+            while(current != to) {
+                new (current) T(*reinterpret_cast<T*>(src));
+                ++current;
+                ++src;
+            }
+        } catch (...) {
+            while (current-- != from)
+                (reinterpret_cast<T*>(current))->~T();
+            throw;
+        }
+    } else {
+        if (src != from && to - from > 0)
+            memcpy(from, src, (to - from) * sizeof(Node *));
+    }
+}
+template <typename T>
+inline void QList<T>::node_destruct(Node *from, Node *to)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
+        while(from != to) --to, delete reinterpret_cast<T*>(to->v);
+    else if (QTypeInfo<T>::isComplex)
+        while (from != to) --to, reinterpret_cast<T*>(to)->~T();
+}
+template <typename T>
+inline QList<T> &QList<T>::operator=(const QList<T> &l)
+{
+    if (d != l.d) {
+        QListData::Data *o = l.d;
+        o->ref.ref();
+        if (!d->ref.deref())
+            free(d);
+        d = o;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+template <typename T>
+inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
+{
+    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
+    Node *n = reinterpret_cast<Node *>(p.insert(iBefore));
+    try {
+        node_construct(n, t);
+    } catch (...) {
+        p.remove(iBefore);
+        throw;
+    }
+    return n;
+}
+template <typename T>
+inline typename QList<T>::iterator QList<T>::erase(iterator it)
+{ node_destruct(it.i);
+ return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); }
+template <typename T>
+inline const T &QList<T>::at(int i) const
+{ qt_noop();
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline const T &QList<T>::operator[](int i) const
+{ qt_noop();
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline T &QList<T>::operator[](int i)
+{ qt_noop();
+  detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline void QList<T>::removeAt(int i)
+{ if(i >= 0 && i < p.size()) { detach();
+ node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
+template <typename T>
+inline T QList<T>::takeAt(int i)
+{ qt_noop();
+ detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
+ p.remove(i); return t; }
+template <typename T>
+inline T QList<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+template <typename T>
+inline T QList<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+template <typename T>
+ void QList<T>::reserve(int alloc)
+{
+    if (d->alloc < alloc) {
+        if (d->ref != 1)
+            detach_helper(alloc);
+        else
+            p.realloc(alloc);
+    }
+}
+template <typename T>
+ void QList<T>::append(const T &t)
+{
+    if (d->ref != 1) {
+        Node *n = detach_helper_grow(2147483647, 1);
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            --d->end;
+            throw;
+        }
+    } else {
+        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+            Node *n = reinterpret_cast<Node *>(p.append());
+            try {
+                node_construct(n, t);
+            } catch (...) {
+                --d->end;
+                throw;
+            }
+        } else {
+            Node *n, copy;
+            node_construct(&copy, t);
+            try {
+                n = reinterpret_cast<Node *>(p.append());;
+            } catch (...) {
+                node_destruct(&copy);
+                throw;
+            }
+            *n = copy;
+        }
+    }
+}
+template <typename T>
+inline void QList<T>::prepend(const T &t)
+{
+    if (d->ref != 1) {
+        Node *n = detach_helper_grow(0, 1);
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            ++d->begin;
+            throw;
+        }
+    } else {
+        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+            Node *n = reinterpret_cast<Node *>(p.prepend());
+            try {
+                node_construct(n, t);
+            } catch (...) {
+                ++d->begin;
+                throw;
+            }
+        } else {
+            Node *n, copy;
+            node_construct(&copy, t);
+            try {
+                n = reinterpret_cast<Node *>(p.prepend());;
+            } catch (...) {
+                node_destruct(&copy);
+                throw;
+            }
+            *n = copy;
+        }
+    }
+}
+template <typename T>
+inline void QList<T>::insert(int i, const T &t)
+{
+    if (d->ref != 1) {
+        Node *n = detach_helper_grow(i, 1);
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            p.remove(i);
+            throw;
+        }
+    } else {
+        if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+            Node *n = reinterpret_cast<Node *>(p.insert(i));
+            try {
+                node_construct(n, t);
+            } catch (...) {
+                p.remove(i);
+                throw;
+            }
+        } else {
+            Node *n, copy;
+            node_construct(&copy, t);
+            try {
+                n = reinterpret_cast<Node *>(p.insert(i));;
+            } catch (...) {
+                node_destruct(&copy);
+                throw;
+            }
+            *n = copy;
+        }
+    }
+}
+template <typename T>
+inline void QList<T>::replace(int i, const T &t)
+{
+    qt_noop();
+    detach();
+    reinterpret_cast<Node *>(p.at(i))->t() = t;
+}
+template <typename T>
+inline void QList<T>::swap(int i, int j)
+{
+    qt_noop()
+                                                       ;
+    detach();
+    void *t = d->array[d->begin + i];
+    d->array[d->begin + i] = d->array[d->begin + j];
+    d->array[d->begin + j] = t;
+}
+template <typename T>
+inline void QList<T>::move(int from, int to)
+{
+    qt_noop()
+                                                      ;
+    detach();
+    p.move(from, to);
+}
+template<typename T>
+ QList<T> QList<T>::mid(int pos, int alength) const
+{
+    if (alength < 0 || pos + alength > size())
+        alength = size() - pos;
+    if (pos == 0 && alength == size())
+        return *this;
+    QList<T> cpy;
+    if (alength <= 0)
+        return cpy;
+    cpy.reserve(alength);
+    cpy.d->end = alength;
+    try {
+        cpy.node_copy(reinterpret_cast<Node *>(cpy.p.begin()),
+                      reinterpret_cast<Node *>(cpy.p.end()),
+                      reinterpret_cast<Node *>(p.begin() + pos));
+    } catch (...) {
+        cpy.d->end = 0;
+        throw;
+    }
+    return cpy;
+}
+template<typename T>
+ T QList<T>::value(int i) const
+{
+    if (i < 0 || i >= p.size()) {
+        return T();
+    }
+    return reinterpret_cast<Node *>(p.at(i))->t();
+}
+template<typename T>
+ T QList<T>::value(int i, const T& defaultValue) const
+{
+    return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
+}
+template <typename T>
+ typename QList<T>::Node *QList<T>::detach_helper_grow(int i, int c)
+{
+    Node *n = reinterpret_cast<Node *>(p.begin());
+    QListData::Data *x = p.detach_grow(&i, c);
+    try {
+        node_copy(reinterpret_cast<Node *>(p.begin()),
+                  reinterpret_cast<Node *>(p.begin() + i), n);
+    } catch (...) {
+        qFree(d);
+        d = x;
+        throw;
+    }
+    try {
+        node_copy(reinterpret_cast<Node *>(p.begin() + i + c),
+                  reinterpret_cast<Node *>(p.end()), n + i);
+    } catch (...) {
+        node_destruct(reinterpret_cast<Node *>(p.begin()),
+                      reinterpret_cast<Node *>(p.begin() + i));
+        qFree(d);
+        d = x;
+        throw;
+    }
+    if (!x->ref.deref())
+        free(x);
+    return reinterpret_cast<Node *>(p.begin() + i);
+}
+template <typename T>
+ void QList<T>::detach_helper(int alloc)
+{
+    Node *n = reinterpret_cast<Node *>(p.begin());
+    QListData::Data *x = p.detach(alloc);
+    try {
+        node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
+    } catch (...) {
+        qFree(d);
+        d = x;
+        throw;
+    }
+    if (!x->ref.deref())
+        free(x);
+}
+template <typename T>
+ void QList<T>::detach_helper()
+{
+    detach_helper(d->alloc);
+}
+template <typename T>
+ QList<T>::~QList()
+{
+    if (!d->ref.deref())
+        free(d);
+}
+template <typename T>
+ bool QList<T>::operator==(const QList<T> &l) const
+{
+    if (p.size() != l.p.size())
+        return false;
+    if (d == l.d)
+        return true;
+    Node *i = reinterpret_cast<Node *>(p.end());
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *li = reinterpret_cast<Node *>(l.p.end());
+    while (i != b) {
+        --i; --li;
+        if (!(i->t() == li->t()))
+            return false;
+    }
+    return true;
+}
+template <typename T>
+ void QList<T>::free(QListData::Data *data)
+{
+    node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
+                  reinterpret_cast<Node *>(data->array + data->end));
+    qFree(data);
+}
+template <typename T>
+ void QList<T>::clear()
+{
+    *this = QList<T>();
+}
+template <typename T>
+ int QList<T>::removeAll(const T &_t)
+{
+    int index = indexOf(_t);
+    if (index == -1)
+        return 0;
+    const T t = _t;
+    detach();
+    Node *i = reinterpret_cast<Node *>(p.at(index));
+    Node *e = reinterpret_cast<Node *>(p.end());
+    Node *n = i;
+    node_destruct(i);
+    while (++i != e) {
+        if (i->t() == t)
+            node_destruct(i);
+        else
+            *n++ = *i;
+    }
+    int removedCount = e - n;
+    d->end -= removedCount;
+    return removedCount;
+}
+template <typename T>
+ bool QList<T>::removeOne(const T &_t)
+{
+    int index = indexOf(_t);
+    if (index != -1) {
+        removeAt(index);
+        return true;
+    }
+    return false;
+}
+template <typename T>
+ typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
+                                                                 typename QList<T>::iterator alast)
+{
+    for (Node *n = afirst.i; n < alast.i; ++n)
+        node_destruct(n);
+    int idx = afirst - begin();
+    p.remove(idx, alast - afirst);
+    return begin() + idx;
+}
+template <typename T>
+ QList<T> &QList<T>::operator+=(const QList<T> &l)
+{
+    if (!l.isEmpty()) {
+        if (isEmpty()) {
+            *this = l;
+        } else {
+            Node *n = (d->ref != 1)
+                      ? detach_helper_grow(2147483647, l.size())
+                      : reinterpret_cast<Node *>(p.append2(l.p));
+            try {
+                node_copy(n, reinterpret_cast<Node *>(p.end()),
+                          reinterpret_cast<Node *>(l.p.begin()));
+            } catch (...) {
+                d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
+                throw;
+            }
+        }
+    }
+    return *this;
+}
+template <typename T>
+inline void QList<T>::append(const QList<T> &t)
+{
+    *this += t;
+}
+template <typename T>
+ int QList<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + p.size(), 0);
+    if (from < p.size()) {
+        Node *n = reinterpret_cast<Node *>(p.at(from -1));
+        Node *e = reinterpret_cast<Node *>(p.end());
+        while (++n != e)
+            if (n->t() == t)
+                return int(n - reinterpret_cast<Node *>(p.begin()));
+    }
+    return -1;
+}
+template <typename T>
+ int QList<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += p.size();
+    else if (from >= p.size())
+        from = p.size()-1;
+    if (from >= 0) {
+        Node *b = reinterpret_cast<Node *>(p.begin());
+        Node *n = reinterpret_cast<Node *>(p.at(from + 1));
+        while (n-- != b) {
+            if (n->t() == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+template <typename T>
+ QBool QList<T>::contains(const T &t) const
+{
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *i = reinterpret_cast<Node *>(p.end());
+    while (i-- != b)
+        if (i->t() == t)
+            return QBool(true);
+    return QBool(false);
+}
+template <typename T>
+ int QList<T>::count(const T &t) const
+{
+    int c = 0;
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *i = reinterpret_cast<Node *>(p.end());
+    while (i-- != b)
+        if (i->t() == t)
+            ++c;
+    return c;
+}
+template <class T> class QListIterator { typedef typename QList<T>::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <class T> class QMutableListIterator { typedef typename QList<T>::iterator iterator; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEvent;
+class QTimerEvent;
+class QChildEvent;
+struct QMetaObject;
+class QVariant;
+class QObjectPrivate;
+class QObject;
+class QThread;
+class QWidget;
+class QRegExp;
+class QObjectUserData;
+typedef QList<QObject*> QObjectList;
+ void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re,
+                                           const QMetaObject &mo, QList<void *> *list);
+ QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo);
+class
+QObjectData {
+public:
+    virtual ~QObjectData() = 0;
+    QObject *q_ptr;
+    QObject *parent;
+    QObjectList children;
+    uint isWidget : 1;
+    uint pendTimer : 1;
+    uint blockSig : 1;
+    uint wasDeleted : 1;
+    uint ownObjectName : 1;
+    uint sendChildEvents : 1;
+    uint receiveChildEvents : 1;
+    uint inEventHandler : 1;
+    uint inThreadChangeEvent : 1;
+    uint hasGuards : 1;
+    uint unused : 22;
+    int postedEvents;
+    QMetaObject *metaObject;
+};
+class QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate;
+public:
+    explicit QObject(QObject *parent=0);
+    virtual ~QObject();
+    virtual bool event(QEvent *);
+    virtual bool eventFilter(QObject *, QEvent *);
+    QString objectName() const;
+    void setObjectName(const QString &name);
+    inline bool isWidgetType() const { return d_ptr->isWidget; }
+    inline bool signalsBlocked() const { return d_ptr->blockSig; }
+    bool blockSignals(bool b);
+    QThread *thread() const;
+    void moveToThread(QThread *thread);
+    int startTimer(int interval);
+    void killTimer(int id);
+    template<typename T>
+    inline T findChild(const QString &aName = QString()) const
+    { return static_cast<T>(qt_qFindChild_helper(this, aName, reinterpret_cast<T>(0)->staticMetaObject)); }
+    template<typename T>
+    inline QList<T> findChildren(const QString &aName = QString()) const
+    {
+        QList<T> list;
+        union {
+            QList<T> *typedList;
+            QList<void *> *voidList;
+        } u;
+        u.typedList = &list;
+        qt_qFindChildren_helper(this, aName, 0, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
+        return list;
+    }
+    template<typename T>
+    inline QList<T> findChildren(const QRegExp &re) const
+    {
+        QList<T> list;
+        union {
+            QList<T> *typedList;
+            QList<void *> *voidList;
+        } u;
+        u.typedList = &list;
+        qt_qFindChildren_helper(this, QString(), &re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
+        return list;
+    }
+    inline const QObjectList &children() const { return d_ptr->children; }
+    void setParent(QObject *);
+    void installEventFilter(QObject *);
+    void removeEventFilter(QObject *);
+    static bool connect(const QObject *sender, const char *signal,
+                        const QObject *receiver, const char *member, Qt::ConnectionType =
+                        Qt::AutoConnection
+        );
+    static bool connect(const QObject *sender, const QMetaMethod &signal,
+                        const QObject *receiver, const QMetaMethod &method,
+                        Qt::ConnectionType type =
+                        Qt::AutoConnection
+        );
+    inline bool connect(const QObject *sender, const char *signal,
+                        const char *member, Qt::ConnectionType type =
+                        Qt::AutoConnection
+        ) const;
+    static bool disconnect(const QObject *sender, const char *signal,
+                           const QObject *receiver, const char *member);
+    static bool disconnect(const QObject *sender, const QMetaMethod &signal,
+                           const QObject *receiver, const QMetaMethod &member);
+    inline bool disconnect(const char *signal = 0,
+                           const QObject *receiver = 0, const char *member = 0)
+        { return disconnect(this, signal, receiver, member); }
+    inline bool disconnect(const QObject *receiver, const char *member = 0)
+        { return disconnect(this, 0, receiver, member); }
+    void dumpObjectTree();
+    void dumpObjectInfo();
+    bool setProperty(const char *name, const QVariant &value);
+    QVariant property(const char *name) const;
+    QList<QByteArray> dynamicPropertyNames() const;
+    static uint registerUserData();
+    void setUserData(uint id, QObjectUserData* data);
+    QObjectUserData* userData(uint id) const;
+protected:
+    void destroyed(QObject * = 0);
+public:
+    inline QObject *parent() const { return d_ptr->parent; }
+    inline bool inherits(const char *classname) const
+        { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; }
+public :
+    void deleteLater();
+protected:
+    QObject *sender() const;
+    int senderSignalIndex() const;
+    int receivers(const char* signal) const;
+    virtual void timerEvent(QTimerEvent *);
+    virtual void childEvent(QChildEvent *);
+    virtual void customEvent(QEvent *);
+    virtual void connectNotify(const char *signal);
+    virtual void disconnectNotify(const char *signal);
+protected:
+    QObject(QObjectPrivate &dd, QObject *parent = 0);
+protected:
+    QScopedPointer<QObjectData> d_ptr;
+    static const QMetaObject staticQtMetaObject;
+    friend struct QMetaObject;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class QCoreApplication;
+    friend class QCoreApplicationPrivate;
+    friend class QWidget;
+    friend class QThreadData;
+private:
+    QObject(const QObject &); QObject &operator=(const QObject &);
+};
+inline bool QObject::connect(const QObject *asender, const char *asignal,
+                             const char *amember, Qt::ConnectionType atype) const
+{ return connect(asender, asignal, this, amember, atype); }
+class QObjectUserData {
+public:
+    virtual ~QObjectUserData();
+};
+template<typename T>
+inline T qFindChild(const QObject *o, const QString &name = QString())
+{ return o->findChild<T>(name); }
+template<typename T>
+inline QList<T> qFindChildren(const QObject *o, const QString &name = QString())
+{
+    return o->findChildren<T>(name);
+}
+template<typename T>
+inline QList<T> qFindChildren(const QObject *o, const QRegExp &re)
+{
+    return o->findChildren<T>(re);
+}
+template <class T>
+inline T qobject_cast(QObject *object)
+{
+    reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object));
+    return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
+}
+template <class T>
+inline T qobject_cast(const QObject *object)
+{
+    reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object)));
+    return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
+}
+template <class T> inline const char * qobject_interface_iid()
+{ return 0; }
+ QDebug operator<<(QDebug, const QObject *);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QByteArray;
+class QIODevicePrivate;
+class QIODevice
+    : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum OpenModeFlag {
+        NotOpen = 0x0000,
+        ReadOnly = 0x0001,
+        WriteOnly = 0x0002,
+        ReadWrite = ReadOnly | WriteOnly,
+        Append = 0x0004,
+        Truncate = 0x0008,
+        Text = 0x0010,
+        Unbuffered = 0x0020
+    };
+    typedef QFlags<OpenModeFlag> OpenMode;
+    QIODevice();
+    explicit QIODevice(QObject *parent);
+    virtual ~QIODevice();
+    OpenMode openMode() const;
+    void setTextModeEnabled(bool enabled);
+    bool isTextModeEnabled() const;
+    bool isOpen() const;
+    bool isReadable() const;
+    bool isWritable() const;
+    virtual bool isSequential() const;
+    virtual bool open(OpenMode mode);
+    virtual void close();
+    virtual qint64 pos() const;
+    virtual qint64 size() const;
+    virtual bool seek(qint64 pos);
+    virtual bool atEnd() const;
+    virtual bool reset();
+    virtual qint64 bytesAvailable() const;
+    virtual qint64 bytesToWrite() const;
+    qint64 read(char *data, qint64 maxlen);
+    QByteArray read(qint64 maxlen);
+    QByteArray readAll();
+    qint64 readLine(char *data, qint64 maxlen);
+    QByteArray readLine(qint64 maxlen = 0);
+    virtual bool canReadLine() const;
+    qint64 write(const char *data, qint64 len);
+    qint64 write(const char *data);
+    inline qint64 write(const QByteArray &data)
+    { return write(data.constData(), data.size()); }
+    qint64 peek(char *data, qint64 maxlen);
+    QByteArray peek(qint64 maxlen);
+    virtual bool waitForReadyRead(int msecs);
+    virtual bool waitForBytesWritten(int msecs);
+    void ungetChar(char c);
+    bool putChar(char c);
+    bool getChar(char *c);
+    QString errorString() const;
+protected:
+    void readyRead();
+    void bytesWritten(qint64 bytes);
+    void aboutToClose();
+    void readChannelFinished();
+protected:
+    QIODevice(QIODevicePrivate &dd, QObject *parent = 0);
+    virtual qint64 readData(char *data, qint64 maxlen) = 0;
+    virtual qint64 readLineData(char *data, qint64 maxlen);
+    virtual qint64 writeData(const char *data, qint64 len) = 0;
+    void setOpenMode(OpenMode openMode);
+    void setErrorString(const QString &errorString);
+private:
+    inline QIODevicePrivate* d_func() { return reinterpret_cast<QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } friend class QIODevicePrivate;
+    QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &);
+};
+ inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+class QDebug;
+ QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QByteArray;
+class QIODevice;
+template <typename T> class QList;
+template <typename T> class QLinkedList;
+template <typename T> class QVector;
+template <typename T> class QSet;
+template <class Key, class T> class QHash;
+template <class Key, class T> class QMap;
+class QDataStreamPrivate;
+class QDataStream
+{
+public:
+    enum Version {
+        Qt_1_0 = 1,
+        Qt_2_0 = 2,
+        Qt_2_1 = 3,
+        Qt_3_0 = 4,
+        Qt_3_1 = 5,
+        Qt_3_3 = 6,
+        Qt_4_0 = 7,
+        Qt_4_1 = Qt_4_0,
+        Qt_4_2 = 8,
+        Qt_4_3 = 9,
+        Qt_4_4 = 10,
+        Qt_4_5 = 11,
+        Qt_4_6 = 12,
+        Qt_4_7 = Qt_4_6,
+        Qt_4_8 = Qt_4_7
+    };
+    enum ByteOrder {
+        BigEndian = QSysInfo::BigEndian,
+        LittleEndian = QSysInfo::LittleEndian
+    };
+    enum Status {
+        Ok,
+        ReadPastEnd,
+        ReadCorruptData,
+        WriteFailed
+    };
+    enum FloatingPointPrecision {
+        SinglePrecision,
+        DoublePrecision
+    };
+    QDataStream();
+    explicit QDataStream(QIODevice *);
+    QDataStream(QByteArray *, QIODevice::OpenMode flags);
+    QDataStream(const QByteArray &);
+    virtual ~QDataStream();
+    QIODevice *device() const;
+    void setDevice(QIODevice *);
+    void unsetDevice();
+    bool atEnd() const;
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+    FloatingPointPrecision floatingPointPrecision() const;
+    void setFloatingPointPrecision(FloatingPointPrecision precision);
+    ByteOrder byteOrder() const;
+    void setByteOrder(ByteOrder);
+    int version() const;
+    void setVersion(int);
+    QDataStream &operator>>(qint8 &i);
+    QDataStream &operator>>(quint8 &i);
+    QDataStream &operator>>(qint16 &i);
+    QDataStream &operator>>(quint16 &i);
+    QDataStream &operator>>(qint32 &i);
+    QDataStream &operator>>(quint32 &i);
+    QDataStream &operator>>(qint64 &i);
+    QDataStream &operator>>(quint64 &i);
+    QDataStream &operator>>(bool &i);
+    QDataStream &operator>>(float &f);
+    QDataStream &operator>>(double &f);
+    QDataStream &operator>>(char *&str);
+    QDataStream &operator<<(qint8 i);
+    QDataStream &operator<<(quint8 i);
+    QDataStream &operator<<(qint16 i);
+    QDataStream &operator<<(quint16 i);
+    QDataStream &operator<<(qint32 i);
+    QDataStream &operator<<(quint32 i);
+    QDataStream &operator<<(qint64 i);
+    QDataStream &operator<<(quint64 i);
+    QDataStream &operator<<(bool i);
+    QDataStream &operator<<(float f);
+    QDataStream &operator<<(double f);
+    QDataStream &operator<<(const char *str);
+    QDataStream &readBytes(char *&, uint &len);
+    int readRawData(char *, int len);
+    QDataStream &writeBytes(const char *, uint len);
+    int writeRawData(const char *, int len);
+    int skipRawData(int len);
+private:
+    QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &);
+    QScopedPointer<QDataStreamPrivate> d;
+    QIODevice *dev;
+    bool owndev;
+    bool noswap;
+    ByteOrder byteorder;
+    int ver;
+    Status q_status;
+};
+inline QIODevice *QDataStream::device() const
+{ return dev; }
+inline QDataStream::ByteOrder QDataStream::byteOrder() const
+{ return byteorder; }
+inline int QDataStream::version() const
+{ return ver; }
+inline void QDataStream::setVersion(int v)
+{ ver = v; }
+inline QDataStream &QDataStream::operator>>(quint8 &i)
+{ return *this >> reinterpret_cast<qint8&>(i); }
+inline QDataStream &QDataStream::operator>>(quint16 &i)
+{ return *this >> reinterpret_cast<qint16&>(i); }
+inline QDataStream &QDataStream::operator>>(quint32 &i)
+{ return *this >> reinterpret_cast<qint32&>(i); }
+inline QDataStream &QDataStream::operator>>(quint64 &i)
+{ return *this >> reinterpret_cast<qint64&>(i); }
+inline QDataStream &QDataStream::operator<<(quint8 i)
+{ return *this << qint8(i); }
+inline QDataStream &QDataStream::operator<<(quint16 i)
+{ return *this << qint16(i); }
+inline QDataStream &QDataStream::operator<<(quint32 i)
+{ return *this << qint32(i); }
+inline QDataStream &QDataStream::operator<<(quint64 i)
+{ return *this << qint64(i); }
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    l.reserve(c);
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QList<T>& l)
+{
+    s << quint32(l.size());
+    for (int i = 0; i < l.size(); ++i)
+        s << l.at(i);
+    return s;
+}
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
+{
+    s << quint32(l.size());
+    typename QLinkedList<T>::ConstIterator it = l.constBegin();
+    for(; it != l.constEnd(); ++it)
+        s << *it;
+    return s;
+}
+template<typename T>
+QDataStream& operator>>(QDataStream& s, QVector<T>& v)
+{
+    v.clear();
+    quint32 c;
+    s >> c;
+    v.resize(c);
+    for(quint32 i = 0; i < c; ++i) {
+        T t;
+        s >> t;
+        v[i] = t;
+    }
+    return s;
+}
+template<typename T>
+QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
+{
+    s << quint32(v.size());
+    for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
+        s << *it;
+    return s;
+}
+template <typename T>
+QDataStream &operator>>(QDataStream &in, QSet<T> &set)
+{
+    set.clear();
+    quint32 c;
+    in >> c;
+    for (quint32 i = 0; i < c; ++i) {
+        T t;
+        in >> t;
+        set << t;
+        if (in.atEnd())
+            break;
+    }
+    return in;
+}
+template <typename T>
+QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
+{
+    out << quint32(set.size());
+    typename QSet<T>::const_iterator i = set.constBegin();
+    while (i != set.constEnd()) {
+        out << *i;
+        ++i;
+    }
+    return out;
+}
+template <class Key, class T>
+ QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    hash.clear();
+    quint32 n;
+    in >> n;
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+        Key k;
+        T t;
+        in >> k >> t;
+        hash.insertMulti(k, t);
+    }
+    if (in.status() != QDataStream::Ok)
+        hash.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+template <class Key, class T>
+ QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
+{
+    out << quint32(hash.size());
+    typename QHash<Key, T>::ConstIterator it = hash.end();
+    typename QHash<Key, T>::ConstIterator begin = hash.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+template <class aKey, class aT>
+ QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    map.clear();
+    quint32 n;
+    in >> n;
+    map.detach();
+    map.setInsertInOrder(true);
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+        aKey key;
+        aT value;
+        in >> key >> value;
+        map.insertMulti(key, value);
+    }
+    map.setInsertInOrder(false);
+    if (in.status() != QDataStream::Ok)
+        map.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+template <class Key, class T>
+ QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
+{
+    out << quint32(map.size());
+    typename QMap<Key, T>::ConstIterator it = map.end();
+    typename QMap<Key, T>::ConstIterator begin = map.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QRegExpPrivate;
+class QStringList;
+class QRegExp
+{
+public:
+    enum PatternSyntax {
+        RegExp,
+        Wildcard,
+        FixedString,
+        RegExp2,
+        WildcardUnix,
+        W3CXmlSchema11 };
+    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };
+    QRegExp();
+    explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive,
+       PatternSyntax syntax = RegExp);
+    QRegExp(const QRegExp &rx);
+    ~QRegExp();
+    QRegExp &operator=(const QRegExp &rx);
+    inline void swap(QRegExp &other) { qSwap(priv, other.priv); }
+    bool operator==(const QRegExp &rx) const;
+    inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); }
+    bool isEmpty() const;
+    bool isValid() const;
+    QString pattern() const;
+    void setPattern(const QString &pattern);
+    Qt::CaseSensitivity caseSensitivity() const;
+    void setCaseSensitivity(Qt::CaseSensitivity cs);
+    PatternSyntax patternSyntax() const;
+    void setPatternSyntax(PatternSyntax syntax);
+    bool isMinimal() const;
+    void setMinimal(bool minimal);
+    bool exactMatch(const QString &str) const;
+    int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const;
+    int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const;
+    int matchedLength() const;
+    int numCaptures() const;
+    int captureCount() const;
+    QStringList capturedTexts() const;
+    QStringList capturedTexts();
+    QString cap(int nth = 0) const;
+    QString cap(int nth = 0);
+    int pos(int nth = 0) const;
+    int pos(int nth = 0);
+    QString errorString() const;
+    QString errorString();
+    static QString escape(const QString &str);
+private:
+    QRegExpPrivate *priv;
+};
+template<> class QTypeInfo<QRegExp > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRegExp"; } };
+ QDataStream &operator<<(QDataStream &out, const QRegExp &regExp);
+ QDataStream &operator>>(QDataStream &in, QRegExp &regExp);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QStringMatcherPrivate;
+class QStringMatcher
+{
+public:
+    QStringMatcher();
+    QStringMatcher(const QString &pattern,
+                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QStringMatcher(const QChar *uc, int len,
+                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QStringMatcher(const QStringMatcher &other);
+    ~QStringMatcher();
+    QStringMatcher &operator=(const QStringMatcher &other);
+    void setPattern(const QString &pattern);
+    void setCaseSensitivity(Qt::CaseSensitivity cs);
+    int indexIn(const QString &str, int from = 0) const;
+    int indexIn(const QChar *str, int length, int from = 0) const;
+    QString pattern() const;
+    inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }
+private:
+    QStringMatcherPrivate *d_ptr;
+    QString q_pattern;
+    Qt::CaseSensitivity q_cs;
+    struct Data {
+        uchar q_skiptable[256];
+        const QChar *uc;
+        int len;
+    };
+    union {
+        uint q_data[256];
+        Data p;
+    };
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QRegExp;
+typedef QListIterator<QString> QStringListIterator;
+typedef QMutableListIterator<QString> QMutableStringListIterator;
+class QStringList : public QList<QString>
+{
+public:
+    inline QStringList() { }
+    inline explicit QStringList(const QString &i) { append(i); }
+    inline QStringList(const QStringList &l) : QList<QString>(l) { }
+    inline QStringList(const QList<QString> &l) : QList<QString>(l) { }
+    inline void sort();
+    inline int removeDuplicates();
+    inline QString join(const QString &sep) const;
+    inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    inline QStringList operator+(const QStringList &other) const
+    { QStringList n = *this; n += other; return n; }
+    inline QStringList &operator<<(const QString &str)
+    { append(str); return *this; }
+    inline QStringList &operator<<(const QStringList &l)
+    { *this += l; return *this; }
+    inline QStringList filter(const QRegExp &rx) const;
+    inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
+    inline int indexOf(const QRegExp &rx, int from = 0) const;
+    inline int lastIndexOf(const QRegExp &rx, int from = -1) const;
+    inline int indexOf(QRegExp &rx, int from = 0) const;
+    inline int lastIndexOf(QRegExp &rx, int from = -1) const;
+    using QList<QString>::indexOf;
+    using QList<QString>::lastIndexOf;
+};
+namespace QtPrivate {
+    void QStringList_sort(QStringList *that);
+    int QStringList_removeDuplicates(QStringList *that);
+    QString QStringList_join(const QStringList *that, const QString &sep);
+    QStringList QStringList_filter(const QStringList *that, const QString &str,
+                                               Qt::CaseSensitivity cs);
+    QBool QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs);
+    void QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after,
+                                      Qt::CaseSensitivity cs);
+    void QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after);
+    QStringList QStringList_filter(const QStringList *that, const QRegExp &re);
+    int QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from);
+    int QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from);
+    int QStringList_indexOf(const QStringList *that, QRegExp &rx, int from);
+    int QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from);
+}
+inline void QStringList::sort()
+{
+    QtPrivate::QStringList_sort(this);
+}
+inline int QStringList::removeDuplicates()
+{
+    return QtPrivate::QStringList_removeDuplicates(this);
+}
+inline QString QStringList::join(const QString &sep) const
+{
+    return QtPrivate::QStringList_join(this, sep);
+}
+inline QStringList QStringList::filter(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_filter(this, str, cs);
+}
+inline QBool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_contains(this, str, cs);
+}
+inline QStringList &QStringList::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
+{
+    QtPrivate::QStringList_replaceInStrings(this, before, after, cs);
+    return *this;
+}
+inline QStringList &QStringList::replaceInStrings(const QRegExp &rx, const QString &after)
+{
+    QtPrivate::QStringList_replaceInStrings(this, rx, after);
+    return *this;
+}
+inline QStringList QStringList::filter(const QRegExp &rx) const
+{
+    return QtPrivate::QStringList_filter(this, rx);
+}
+inline int QStringList::indexOf(const QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_indexOf(this, rx, from);
+}
+inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
+}
+inline int QStringList::indexOf(QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_indexOf(this, rx, from);
+}
+inline int QStringList::lastIndexOf(QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
+}
+inline QDataStream &operator>>(QDataStream &in, QStringList &list)
+{
+    return operator>>(in, static_cast<QList<QString> &>(list));
+}
+inline QDataStream &operator<<(QDataStream &out, const QStringList &list)
+{
+    return operator<<(out, static_cast<const QList<QString> &>(list));
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QBitRef;
+class QBitArray
+{
+    friend QDataStream &operator<<(QDataStream &, const QBitArray &);
+    friend QDataStream &operator>>(QDataStream &, QBitArray &);
+    friend uint qHash(const QBitArray &key);
+    QByteArray d;
+public:
+    inline QBitArray() {}
+    explicit QBitArray(int size, bool val = false);
+    QBitArray(const QBitArray &other) : d(other.d) {}
+    inline QBitArray &operator=(const QBitArray &other) { d = other.d; return *this; }
+    inline void swap(QBitArray &other) { qSwap(d, other.d); }
+    inline int size() const { return (d.size() << 3) - *d.constData(); }
+    inline int count() const { return (d.size() << 3) - *d.constData(); }
+    int count(bool on) const;
+    inline bool isEmpty() const { return d.isEmpty(); }
+    inline bool isNull() const { return d.isNull(); }
+    void resize(int size);
+    inline void detach() { d.detach(); }
+    inline bool isDetached() const { return d.isDetached(); }
+    inline void clear() { d.clear(); }
+    bool testBit(int i) const;
+    void setBit(int i);
+    void setBit(int i, bool val);
+    void clearBit(int i);
+    bool toggleBit(int i);
+    bool at(int i) const;
+    QBitRef operator[](int i);
+    bool operator[](int i) const;
+    QBitRef operator[](uint i);
+    bool operator[](uint i) const;
+    QBitArray& operator&=(const QBitArray &);
+    QBitArray& operator|=(const QBitArray &);
+    QBitArray& operator^=(const QBitArray &);
+    QBitArray operator~() const;
+    inline bool operator==(const QBitArray& a) const { return d == a.d; }
+    inline bool operator!=(const QBitArray& a) const { return d != a.d; }
+    inline bool fill(bool val, int size = -1);
+    void fill(bool val, int first, int last);
+    inline void truncate(int pos) { if (pos < size()) resize(pos); }
+public:
+    typedef QByteArray::DataPtr DataPtr;
+    inline DataPtr &data_ptr() { return d.data_ptr(); }
+};
+inline bool QBitArray::fill(bool aval, int asize)
+{ *this = QBitArray((asize < 0 ? this->size() : asize), aval); return true; }
+ QBitArray operator&(const QBitArray &, const QBitArray &);
+ QBitArray operator|(const QBitArray &, const QBitArray &);
+ QBitArray operator^(const QBitArray &, const QBitArray &);
+inline bool QBitArray::testBit(int i) const
+{ qt_noop();
+ return (*(reinterpret_cast<const uchar*>(d.constData())+1+(i>>3)) & (1 << (i & 7))) != 0; }
+inline void QBitArray::setBit(int i)
+{ qt_noop();
+ *(reinterpret_cast<uchar*>(d.data())+1+(i>>3)) |= uchar(1 << (i & 7)); }
+inline void QBitArray::clearBit(int i)
+{ qt_noop();
+ *(reinterpret_cast<uchar*>(d.data())+1+(i>>3)) &= ~uchar(1 << (i & 7)); }
+inline void QBitArray::setBit(int i, bool val)
+{ if (val) setBit(i); else clearBit(i); }
+inline bool QBitArray::toggleBit(int i)
+{ qt_noop();
+ uchar b = uchar(1<<(i&7)); uchar* p = reinterpret_cast<uchar*>(d.data())+1+(i>>3);
+ uchar c = uchar(*p&b); *p^=b; return c!=0; }
+inline bool QBitArray::operator[](int i) const { return testBit(i); }
+inline bool QBitArray::operator[](uint i) const { return testBit(i); }
+inline bool QBitArray::at(int i) const { return testBit(i); }
+class QBitRef
+{
+private:
+    QBitArray& a;
+    int i;
+    inline QBitRef(QBitArray& array, int idx) : a(array), i(idx) {}
+    friend class QBitArray;
+public:
+    inline operator bool() const { return a.testBit(i); }
+    inline bool operator!() const { return !a.testBit(i); }
+    QBitRef& operator=(const QBitRef& val) { a.setBit(i, val); return *this; }
+    QBitRef& operator=(bool val) { a.setBit(i, val); return *this; }
+};
+inline QBitRef QBitArray::operator[](int i)
+{ qt_noop(); return QBitRef(*this, i); }
+inline QBitRef QBitArray::operator[](uint i)
+{ return QBitRef(*this, i); }
+ QDataStream &operator<<(QDataStream &, const QBitArray &);
+ QDataStream &operator>>(QDataStream &, QBitArray &);
+template<> class QTypeInfo<QBitArray > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QBitArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QBitArray"; } };
+template <> inline bool qIsDetached<QBitArray>(QBitArray &t) { return t.isDetached(); } template <> inline void qSwap<QBitArray>(QBitArray &value1, QBitArray &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QBitArray>(::QBitArray &value1, ::QBitArray &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QByteArrayMatcherPrivate;
+class QByteArrayMatcher
+{
+public:
+    QByteArrayMatcher();
+    explicit QByteArrayMatcher(const QByteArray &pattern);
+    explicit QByteArrayMatcher(const char *pattern, int length);
+    QByteArrayMatcher(const QByteArrayMatcher &other);
+    ~QByteArrayMatcher();
+    QByteArrayMatcher &operator=(const QByteArrayMatcher &other);
+    void setPattern(const QByteArray &pattern);
+    int indexIn(const QByteArray &ba, int from = 0) const;
+    int indexIn(const char *str, int len, int from = 0) const;
+    inline QByteArray pattern() const
+    {
+        if (q_pattern.isNull())
+            return QByteArray(reinterpret_cast<const char*>(p.p), p.l);
+        return q_pattern;
+    }
+private:
+    QByteArrayMatcherPrivate *d;
+    QByteArray q_pattern;
+    struct Data {
+        uchar q_skiptable[256];
+        const uchar *p;
+        int l;
+    };
+    union {
+        uint dummy[256];
+        Data p;
+    };
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T1, class T2>
+struct QPair
+{
+    typedef T1 first_type;
+    typedef T2 second_type;
+    QPair() : first(T1()), second(T2()) {}
+    QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {}
+    QPair<T1, T2> &operator=(const QPair<T1, T2> &other)
+    { first = other.first; second = other.second; return *this; }
+    T1 first;
+    T2 second;
+};
+template <class T1, class T2>
+inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{ return p1.first == p2.first && p1.second == p2.second; }
+template <class T1, class T2>
+inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{ return !(p1 == p2); }
+template <class T1, class T2>
+inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
+}
+template <class T1, class T2>
+inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return p2 < p1;
+}
+template <class T1, class T2>
+inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return !(p2 < p1);
+}
+template <class T1, class T2>
+inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return !(p1 < p2);
+}
+template <class T1, class T2>
+ QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
+{
+    return QPair<T1, T2>(x, y);
+}
+template <class T1, class T2>
+inline QDataStream& operator>>(QDataStream& s, QPair<T1, T2>& p)
+{
+    s >> p.first >> p.second;
+    return s;
+}
+template <class T1, class T2>
+inline QDataStream& operator<<(QDataStream& s, const QPair<T1, T2>& p)
+{
+    s << p.first << p.second;
+    return s;
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QBitArray;
+class QByteArray;
+class QString;
+class QStringRef;
+inline uint qHash(char key) { return uint(key); }
+inline uint qHash(uchar key) { return uint(key); }
+inline uint qHash(signed char key) { return uint(key); }
+inline uint qHash(ushort key) { return uint(key); }
+inline uint qHash(short key) { return uint(key); }
+inline uint qHash(uint key) { return key; }
+inline uint qHash(int key) { return uint(key); }
+inline uint qHash(ulong key)
+{
+    if (sizeof(ulong) > sizeof(uint)) {
+        return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U));
+    } else {
+        return uint(key & (~0U));
+    }
+}
+inline uint qHash(long key) { return qHash(ulong(key)); }
+inline uint qHash(quint64 key)
+{
+    if (sizeof(quint64) > sizeof(uint)) {
+        return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U));
+    } else {
+        return uint(key & (~0U));
+    }
+}
+inline uint qHash(qint64 key) { return qHash(quint64(key)); }
+inline uint qHash(QChar key) { return qHash(key.unicode()); }
+ uint qHash(const QByteArray &key);
+ uint qHash(const QString &key);
+ uint qHash(const QStringRef &key);
+ uint qHash(const QBitArray &key);
+template <class T> inline uint qHash(const T *key)
+{
+    return qHash(reinterpret_cast<quintptr>(key));
+}
+template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key)
+{
+    uint h1 = qHash(key.first);
+    uint h2 = qHash(key.second);
+    return ((h1 << 16) | (h1 >> 16)) ^ h2;
+}
+struct QHashData
+{
+    struct Node {
+        Node *next;
+        uint h;
+    };
+    Node *fakeNext;
+    Node **buckets;
+    QBasicAtomicInt ref;
+    int size;
+    int nodeSize;
+    short userNumBits;
+    short numBits;
+    int numBuckets;
+    uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 30;
+    void *allocateNode();
+    void *allocateNode(int nodeAlign);
+    void freeNode(void *node);
+    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize);
+    QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
+                              int nodeSize, int nodeAlign);
+    void mightGrow();
+    bool willGrow();
+    void hasShrunk();
+    void rehash(int hint);
+    void free_helper(void (*node_delete)(Node *));
+    void destroyAndFree();
+    Node *firstNode();
+    static Node *nextNode(Node *node);
+    static Node *previousNode(Node *node);
+    static QHashData shared_null;
+};
+inline void QHashData::mightGrow()
+{
+    if (size >= numBuckets)
+        rehash(numBits + 1);
+}
+inline bool QHashData::willGrow()
+{
+    if (size >= numBuckets) {
+        rehash(numBits + 1);
+        return true;
+    } else {
+        return false;
+    }
+}
+inline void QHashData::hasShrunk()
+{
+    if (size <= (numBuckets >> 3) && numBits > userNumBits) {
+        try {
+            rehash(qMax(int(numBits) - 2, int(userNumBits)));
+        } catch (const std::bad_alloc &) {
+        }
+    }
+}
+inline QHashData::Node *QHashData::firstNode()
+{
+    Node *e = reinterpret_cast<Node *>(this);
+    Node **bucket = buckets;
+    int n = numBuckets;
+    while (n--) {
+        if (*bucket != e)
+            return *bucket;
+        ++bucket;
+    }
+    return e;
+}
+struct QHashDummyValue
+{
+};
+inline bool operator==(const QHashDummyValue & , const QHashDummyValue & )
+{
+    return true;
+}
+template<> class QTypeInfo<QHashDummyValue > { public: enum { isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QHashDummyValue"; } };
+template <class Key, class T>
+struct QHashDummyNode
+{
+    QHashDummyNode *next;
+    uint h;
+    Key key;
+    inline QHashDummyNode(const Key &key0) : key(key0) {}
+};
+template <class Key, class T>
+struct QHashNode
+{
+    QHashNode *next;
+    uint h;
+    Key key;
+    T value;
+    inline QHashNode(const Key &key0) : key(key0) {}
+    inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {}
+    inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
+};
+template <class T> struct QHashDummyNode<int, T> { QHashDummyNode *next; union { uint h; int key; }; inline QHashDummyNode(int ) {} }; template <class T> struct QHashNode<int, T> { QHashNode *next; union { uint h; int key; }; T value; inline QHashNode(int ) {} inline QHashNode(int , const T &value0) : value(value0) {} inline bool same_key(uint h0, int) { return h0 == h; } };
+template <class T> struct QHashDummyNode<uint, T> { QHashDummyNode *next; union { uint h; uint key; }; inline QHashDummyNode(uint ) {} }; template <class T> struct QHashNode<uint, T> { QHashNode *next; union { uint h; uint key; }; T value; inline QHashNode(uint ) {} inline QHashNode(uint , const T &value0) : value(value0) {} inline bool same_key(uint h0, uint) { return h0 == h; } };
+template <class Key, class T>
+class QHash
+{
+    typedef QHashDummyNode<Key, T> DummyNode;
+    typedef QHashNode<Key, T> Node;
+    union {
+        QHashData *d;
+        QHashNode<Key, T> *e;
+    };
+    static inline Node *concrete(QHashData::Node *node) {
+        return reinterpret_cast<Node *>(node);
+    }
+    static inline int alignOfNode() { return qMax<int>(sizeof(void*), __alignof__(Node)); }
+    static inline int alignOfDummyNode() { return qMax<int>(sizeof(void*), __alignof__(DummyNode)); }
+public:
+    inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); }
+    inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
+    inline ~QHash() { if (!d->ref.deref()) freeData(d); }
+    QHash<Key, T> &operator=(const QHash<Key, T> &other);
+    inline void swap(QHash<Key, T> &other) { qSwap(d, other.d); }
+    bool operator==(const QHash<Key, T> &other) const;
+    inline bool operator!=(const QHash<Key, T> &other) const { return !(*this == other); }
+    inline int size() const { return d->size; }
+    inline bool isEmpty() const { return d->size == 0; }
+    inline int capacity() const { return d->numBuckets; }
+    void reserve(int size);
+    inline void squeeze() { reserve(1); }
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline bool isSharedWith(const QHash<Key, T> &other) const { return d == other.d; }
+    void clear();
+    int remove(const Key &key);
+    T take(const Key &key);
+    bool contains(const Key &key) const;
+    const Key key(const T &value) const;
+    const Key key(const T &value, const Key &defaultKey) const;
+    const T value(const Key &key) const;
+    const T value(const Key &key, const T &defaultValue) const;
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+    QList<Key> uniqueKeys() const;
+    QList<Key> keys() const;
+    QList<Key> keys(const T &value) const;
+    QList<T> values() const;
+    QList<T> values(const Key &key) const;
+    int count(const Key &key) const;
+    class const_iterator;
+    class iterator
+    {
+        friend class const_iterator;
+        QHashData::Node *i;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+        inline operator Node *() const { return concrete(i); }
+        inline iterator() : i(0) { }
+        explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(node)) { }
+        inline const Key &key() const { return concrete(i)->key; }
+        inline T &value() const { return concrete(i)->value; }
+        inline T &operator*() const { return concrete(i)->value; }
+        inline T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline iterator &operator++() {
+            i = QHashData::nextNode(i);
+            return *this;
+        }
+        inline iterator operator++(int) {
+            iterator r = *this;
+            i = QHashData::nextNode(i);
+            return r;
+        }
+        inline iterator &operator--() {
+            i = QHashData::previousNode(i);
+            return *this;
+        }
+        inline iterator operator--(int) {
+            iterator r = *this;
+            i = QHashData::previousNode(i);
+            return r;
+        }
+        inline iterator operator+(int j) const
+        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { return *this = *this + j; }
+        inline iterator &operator-=(int j) { return *this = *this - j; }
+    public:
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+    private:
+        inline operator bool() const { return false; }
+    };
+    friend class iterator;
+    class const_iterator
+    {
+        friend class iterator;
+        QHashData::Node *i;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline operator Node *() const { return concrete(i); }
+        inline const_iterator() : i(0) { }
+        explicit inline const_iterator(void *node)
+            : i(reinterpret_cast<QHashData::Node *>(node)) { }
+        inline const_iterator(const iterator &o)
+        { i = o.i; }
+        inline const Key &key() const { return concrete(i)->key; }
+        inline const T &value() const { return concrete(i)->value; }
+        inline const T &operator*() const { return concrete(i)->value; }
+        inline const T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() {
+            i = QHashData::nextNode(i);
+            return *this;
+        }
+        inline const_iterator operator++(int) {
+            const_iterator r = *this;
+            i = QHashData::nextNode(i);
+            return r;
+        }
+        inline const_iterator &operator--() {
+            i = QHashData::previousNode(i);
+            return *this;
+        }
+        inline const_iterator operator--(int) {
+            const_iterator r = *this;
+            i = QHashData::previousNode(i);
+            return r;
+        }
+        inline const_iterator operator+(int j) const
+        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { return *this = *this + j; }
+        inline const_iterator &operator-=(int j) { return *this = *this - j; }
+    private:
+        inline operator bool() const { return false; }
+    };
+    friend class const_iterator;
+    inline iterator begin() { detach(); return iterator(d->firstNode()); }
+    inline const_iterator begin() const { return const_iterator(d->firstNode()); }
+    inline const_iterator constBegin() const { return const_iterator(d->firstNode()); }
+    inline iterator end() { detach(); return iterator(e); }
+    inline const_iterator end() const { return const_iterator(e); }
+    inline const_iterator constEnd() const { return const_iterator(e); }
+    iterator erase(iterator it);
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+    iterator insertMulti(const Key &key, const T &value);
+    QHash<Key, T> &unite(const QHash<Key, T> &other);
+    typedef T mapped_type;
+    typedef Key key_type;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+    inline bool empty() const { return isEmpty(); }
+private:
+    void detach_helper();
+    void freeData(QHashData *d);
+    Node **findNode(const Key &key, uint *hp = 0) const;
+    Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
+    void deleteNode(Node *node);
+    static void deleteNode2(QHashData::Node *node);
+    static void duplicateNode(QHashData::Node *originalNode, void *newNode);
+};
+template <class Key, class T>
+inline void QHash<Key, T>::deleteNode(Node *node)
+{
+    deleteNode2(reinterpret_cast<QHashData::Node*>(node));
+    d->freeNode(node);
+}
+template <class Key, class T>
+inline void QHash<Key, T>::deleteNode2(QHashData::Node *node)
+{
+    concrete(node)->~Node();
+}
+template <class Key, class T>
+inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode)
+{
+    Node *concreteNode = concrete(node);
+    if (QTypeInfo<T>::isDummy) {
+        (void) new (newNode) DummyNode(concreteNode->key);
+    } else {
+        (void) new (newNode) Node(concreteNode->key, concreteNode->value);
+    }
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::Node *
+QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode)
+{
+    Node *node;
+    if (QTypeInfo<T>::isDummy) {
+        node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey));
+    } else {
+        node = new (d->allocateNode(alignOfNode())) Node(akey, avalue);
+    }
+    node->h = ah;
+    node->next = *anextNode;
+    *anextNode = node;
+    ++d->size;
+    return node;
+}
+template <class Key, class T>
+inline QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other)
+{
+    QHash<Key, T> copy(other);
+    const_iterator it = copy.constEnd();
+    while (it != copy.constBegin()) {
+        --it;
+        insertMulti(it.key(), it.value());
+    }
+    return *this;
+}
+template <class Key, class T>
+ void QHash<Key, T>::freeData(QHashData *x)
+{
+    x->free_helper(deleteNode2);
+}
+template <class Key, class T>
+inline void QHash<Key, T>::clear()
+{
+    *this = QHash<Key,T>();
+}
+template <class Key, class T>
+ void QHash<Key, T>::detach_helper()
+{
+    QHashData *x = d->detach_helper2(duplicateNode, deleteNode2,
+        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
+        QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
+    if (!d->ref.deref())
+        freeData(d);
+    d = x;
+}
+template <class Key, class T>
+inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &other)
+{
+    if (d != other.d) {
+        QHashData *o = other.d;
+        o->ref.ref();
+        if (!d->ref.deref())
+            freeData(d);
+        d = o;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+template <class Key, class T>
+inline const T QHash<Key, T>::value(const Key &akey) const
+{
+    Node *node;
+    if (d->size == 0 || (node = *findNode(akey)) == e) {
+        return T();
+    } else {
+        return node->value;
+    }
+}
+template <class Key, class T>
+inline const T QHash<Key, T>::value(const Key &akey, const T &adefaultValue) const
+{
+    Node *node;
+    if (d->size == 0 || (node = *findNode(akey)) == e) {
+        return adefaultValue;
+    } else {
+        return node->value;
+    }
+}
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::uniqueKeys() const
+{
+    QList<Key> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    if (i != end()) {
+        for (;;) {
+            const Key &aKey = i.key();
+            res.append(aKey);
+            do {
+                if (++i == end())
+                    goto break_out_of_outer_loop;
+            } while (aKey == i.key());
+        }
+    }
+break_out_of_outer_loop:
+    return res;
+}
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::keys() const
+{
+    QList<Key> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::keys(const T &avalue) const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ const Key QHash<Key, T>::key(const T &avalue) const
+{
+    return key(avalue, Key());
+}
+template <class Key, class T>
+ const Key QHash<Key, T>::key(const T &avalue, const Key &defaultValue) const
+{
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            return i.key();
+        ++i;
+    }
+    return defaultValue;
+}
+template <class Key, class T>
+ QList<T> QHash<Key, T>::values() const
+{
+    QList<T> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.value());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ QList<T> QHash<Key, T>::values(const Key &akey) const
+{
+    QList<T> res;
+    Node *node = *findNode(akey);
+    if (node != e) {
+        do {
+            res.append(node->value);
+        } while ((node = node->next) != e && node->key == akey);
+    }
+    return res;
+}
+template <class Key, class T>
+ int QHash<Key, T>::count(const Key &akey) const
+{
+    int cnt = 0;
+    Node *node = *findNode(akey);
+    if (node != e) {
+        do {
+            ++cnt;
+        } while ((node = node->next) != e && node->key == akey);
+    }
+    return cnt;
+}
+template <class Key, class T>
+inline const T QHash<Key, T>::operator[](const Key &akey) const
+{
+    return value(akey);
+}
+template <class Key, class T>
+inline T &QHash<Key, T>::operator[](const Key &akey)
+{
+    detach();
+    uint h;
+    Node **node = findNode(akey, &h);
+    if (*node == e) {
+        if (d->willGrow())
+            node = findNode(akey, &h);
+        return createNode(h, akey, T(), node)->value;
+    }
+    return (*node)->value;
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &akey,
+                                                                         const T &avalue)
+{
+    detach();
+    uint h;
+    Node **node = findNode(akey, &h);
+    if (*node == e) {
+        if (d->willGrow())
+            node = findNode(akey, &h);
+        return iterator(createNode(h, akey, avalue, node));
+    }
+    if (!QTypeInfo<T>::isDummy)
+        (*node)->value = avalue;
+    return iterator(*node);
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::insertMulti(const Key &akey,
+                                                                              const T &avalue)
+{
+    detach();
+    d->willGrow();
+    uint h;
+    Node **nextNode = findNode(akey, &h);
+    return iterator(createNode(h, akey, avalue, nextNode));
+}
+template <class Key, class T>
+ int QHash<Key, T>::remove(const Key &akey)
+{
+    if (isEmpty())
+        return 0;
+    detach();
+    int oldSize = d->size;
+    Node **node = findNode(akey);
+    if (*node != e) {
+        bool deleteNext = true;
+        do {
+            Node *next = (*node)->next;
+            deleteNext = (next != e && next->key == (*node)->key);
+            deleteNode(*node);
+            *node = next;
+            --d->size;
+        } while (deleteNext);
+        d->hasShrunk();
+    }
+    return oldSize - d->size;
+}
+template <class Key, class T>
+ T QHash<Key, T>::take(const Key &akey)
+{
+    if (isEmpty())
+        return T();
+    detach();
+    Node **node = findNode(akey);
+    if (*node != e) {
+        T t = (*node)->value;
+        Node *next = (*node)->next;
+        deleteNode(*node);
+        *node = next;
+        --d->size;
+        d->hasShrunk();
+        return t;
+    }
+    return T();
+}
+template <class Key, class T>
+ typename QHash<Key, T>::iterator QHash<Key, T>::erase(iterator it)
+{
+    if (it == iterator(e))
+        return it;
+    iterator ret = it;
+    ++ret;
+    Node *node = it;
+    Node **node_ptr = reinterpret_cast<Node **>(&d->buckets[node->h % d->numBuckets]);
+    while (*node_ptr != node)
+        node_ptr = &(*node_ptr)->next;
+    *node_ptr = node->next;
+    deleteNode(node);
+    --d->size;
+    return ret;
+}
+template <class Key, class T>
+inline void QHash<Key, T>::reserve(int asize)
+{
+    detach();
+    d->rehash(-qMax(asize, 1));
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const
+{
+    return const_iterator(*findNode(akey));
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const
+{
+    return const_iterator(*findNode(akey));
+}
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey)
+{
+    detach();
+    return iterator(*findNode(akey));
+}
+template <class Key, class T>
+inline bool QHash<Key, T>::contains(const Key &akey) const
+{
+    return *findNode(akey) != e;
+}
+template <class Key, class T>
+ typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
+                                                                            uint *ahp) const
+{
+    Node **node;
+    uint h = qHash(akey);
+    if (d->numBuckets) {
+        node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
+        qt_noop();
+        while (*node != e && !(*node)->same_key(h, akey))
+            node = &(*node)->next;
+    } else {
+        node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e));
+    }
+    if (ahp)
+        *ahp = h;
+    return node;
+}
+template <class Key, class T>
+ bool QHash<Key, T>::operator==(const QHash<Key, T> &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+    const_iterator it = begin();
+    while (it != end()) {
+        const Key &akey = it.key();
+        const_iterator it2 = other.find(akey);
+        do {
+            if (it2 == other.end() || !(it2.key() == akey))
+                return false;
+            if (!QTypeInfo<T>::isDummy && !(it.value() == it2.value()))
+                return false;
+            ++it;
+            ++it2;
+        } while (it != end() && it.key() == akey);
+    }
+    return true;
+}
+template <class Key, class T>
+class QMultiHash : public QHash<Key, T>
+{
+public:
+    QMultiHash() {}
+    QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
+    inline void swap(QMultiHash<Key, T> &other) { QHash<Key, T>::swap(other); }
+    inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value)
+    { return QHash<Key, T>::insert(key, value); }
+    inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value)
+    { return QHash<Key, T>::insertMulti(key, value); }
+    inline QMultiHash &operator+=(const QMultiHash &other)
+    { this->unite(other); return *this; }
+    inline QMultiHash operator+(const QMultiHash &other) const
+    { QMultiHash result = *this; result += other; return result; }
+    using QHash<Key, T>::contains;
+    using QHash<Key, T>::remove;
+    using QHash<Key, T>::count;
+    using QHash<Key, T>::find;
+    using QHash<Key, T>::constFind;
+    bool contains(const Key &key, const T &value) const;
+    int remove(const Key &key, const T &value);
+    int count(const Key &key, const T &value) const;
+    typename QHash<Key, T>::iterator find(const Key &key, const T &value) {
+        typename QHash<Key, T>::iterator i(find(key));
+        typename QHash<Key, T>::iterator end(this->end());
+        while (i != end && i.key() == key) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const {
+        typename QHash<Key, T>::const_iterator i(constFind(key));
+        typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
+        while (i != end && i.key() == key) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QHash<Key, T>::const_iterator constFind(const Key &key, const T &value) const
+        { return find(key, value); }
+private:
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+};
+template <class Key, class T>
+inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
+{
+    return constFind(key, value) != QHash<Key, T>::constEnd();
+}
+template <class Key, class T>
+inline int QMultiHash<Key, T>::remove(const Key &key, const T &value)
+{
+    int n = 0;
+    typename QHash<Key, T>::iterator i(find(key));
+    typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
+    while (i != end && i.key() == key) {
+        if (i.value() == value) {
+            i = this->erase(i);
+            ++n;
+        } else {
+            ++i;
+        }
+    }
+    return n;
+}
+template <class Key, class T>
+inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const
+{
+    int n = 0;
+    typename QHash<Key, T>::const_iterator i(constFind(key));
+    typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
+    while (i != end && i.key() == key) {
+        if (i.value() == value)
+            ++n;
+        ++i;
+    }
+    return n;
+}
+template <class Key, class T> class QHashIterator { typedef typename QHash<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QHash<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QHashIterator(const QHash<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QHashIterator &operator=(const QHash<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } };
+template <class Key, class T> class QMutableHashIterator { typedef typename QHash<Key,T>::iterator iterator; typedef typename QHash<Key,T>::const_iterator const_iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableHashIterator(QHash<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class Key, class T>
+class QCache
+{
+    struct Node {
+        inline Node() : keyPtr(0) {}
+        inline Node(T *data, int cost)
+            : keyPtr(0), t(data), c(cost), p(0), n(0) {}
+        const Key *keyPtr; T *t; int c; Node *p,*n;
+    };
+    Node *f, *l;
+    QHash<Key, Node> hash;
+    void *unused;
+    int mx, total;
+    inline void unlink(Node &n) {
+        if (n.p) n.p->n = n.n;
+        if (n.n) n.n->p = n.p;
+        if (l == &n) l = n.p;
+        if (f == &n) f = n.n;
+        total -= n.c;
+        T *obj = n.t;
+        hash.remove(*n.keyPtr);
+        delete obj;
+    }
+    inline T *relink(const Key &key) {
+        typename QHash<Key, Node>::iterator i = hash.find(key);
+        if (typename QHash<Key, Node>::const_iterator(i) == hash.constEnd())
+            return 0;
+        Node &n = *i;
+        if (f != &n) {
+            if (n.p) n.p->n = n.n;
+            if (n.n) n.n->p = n.p;
+            if (l == &n) l = n.p;
+            n.p = 0;
+            n.n = f;
+            f->p = &n;
+            f = &n;
+        }
+        return n.t;
+    }
+    QCache(const QCache &); QCache &operator=(const QCache &);
+public:
+    inline explicit QCache(int maxCost = 100);
+    inline ~QCache() { clear(); }
+    inline int maxCost() const { return mx; }
+    void setMaxCost(int m);
+    inline int totalCost() const { return total; }
+    inline int size() const { return hash.size(); }
+    inline int count() const { return hash.size(); }
+    inline bool isEmpty() const { return hash.isEmpty(); }
+    inline QList<Key> keys() const { return hash.keys(); }
+    void clear();
+    bool insert(const Key &key, T *object, int cost = 1);
+    T *object(const Key &key) const;
+    inline bool contains(const Key &key) const { return hash.contains(key); }
+    T *operator[](const Key &key) const;
+    bool remove(const Key &key);
+    T *take(const Key &key);
+private:
+    void trim(int m);
+};
+template <class Key, class T>
+inline QCache<Key, T>::QCache(int amaxCost)
+    : f(0), l(0), unused(0), mx(amaxCost), total(0) {}
+template <class Key, class T>
+inline void QCache<Key,T>::clear()
+{ while (f) { delete f->t; f = f->n; }
+ hash.clear(); l = 0; total = 0; }
+template <class Key, class T>
+inline void QCache<Key,T>::setMaxCost(int m)
+{ mx = m; trim(mx); }
+template <class Key, class T>
+inline T *QCache<Key,T>::object(const Key &key) const
+{ return const_cast<QCache<Key,T>*>(this)->relink(key); }
+template <class Key, class T>
+inline T *QCache<Key,T>::operator[](const Key &key) const
+{ return object(key); }
+template <class Key, class T>
+inline bool QCache<Key,T>::remove(const Key &key)
+{
+    typename QHash<Key, Node>::iterator i = hash.find(key);
+    if (typename QHash<Key, Node>::const_iterator(i) == hash.constEnd()) {
+        return false;
+    } else {
+        unlink(*i);
+        return true;
+    }
+}
+template <class Key, class T>
+inline T *QCache<Key,T>::take(const Key &key)
+{
+    typename QHash<Key, Node>::iterator i = hash.find(key);
+    if (i == hash.end())
+        return 0;
+    Node &n = *i;
+    T *t = n.t;
+    n.t = 0;
+    unlink(n);
+    return t;
+}
+template <class Key, class T>
+bool QCache<Key,T>::insert(const Key &akey, T *aobject, int acost)
+{
+    remove(akey);
+    if (acost > mx) {
+        delete aobject;
+        return false;
+    }
+    trim(mx - acost);
+    Node sn(aobject, acost);
+    typename QHash<Key, Node>::iterator i = hash.insert(akey, sn);
+    total += acost;
+    Node *n = &i.value();
+    n->keyPtr = &i.key();
+    if (f) f->p = n;
+    n->n = f;
+    f = n;
+    if (!l) l = f;
+    return true;
+}
+template <class Key, class T>
+void QCache<Key,T>::trim(int m)
+{
+    Node *n = l;
+    while (n && total > m) {
+        Node *u = n;
+        n = n->p;
+        unlink(*u);
+    }
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class Key, class T> class QCache;
+template <class Key, class T> class QHash;
+template <class T> class QLinkedList;
+template <class T> class QList;
+template <class Key, class T> class QMap;
+template <class Key, class T> class QMultiHash;
+template <class Key, class T> class QMultiMap;
+template <class T1, class T2> struct QPair;
+template <class T> class QQueue;
+template <class T> class QSet;
+template <class T> class QStack;
+template<class T, int Prealloc = 256> class QVarLengthArray;
+template <class T> class QVector;
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QContiguousCacheData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int count;
+    int start;
+    int offset;
+    uint sharable : 1;
+    uint reserved : 31;
+    static QContiguousCacheData *allocate(int size, int alignment);
+    static void free(QContiguousCacheData *data);
+};
+template <typename T>
+struct QContiguousCacheTypedData: private QContiguousCacheData
+{
+    T array[1];
+    static inline void free(QContiguousCacheTypedData *data) { QContiguousCacheData::free(data); }
+};
+template<typename T>
+class QContiguousCache {
+    typedef QContiguousCacheTypedData<T> Data;
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
+public:
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+    explicit QContiguousCache(int capacity = 0);
+    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(p); }
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
+    inline void swap(QContiguousCache<T> &other) { qSwap(d, other.d); }
+    bool operator==(const QContiguousCache<T> &other) const;
+    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }
+    inline int capacity() const {return d->alloc; }
+    inline int count() const { return d->count; }
+    inline int size() const { return d->count; }
+    inline bool isEmpty() const { return d->count == 0; }
+    inline bool isFull() const { return d->count == d->alloc; }
+    inline int available() const { return d->alloc - d->count; }
+    void clear();
+    void setCapacity(int size);
+    const T &at(int pos) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+    void append(const T &value);
+    void prepend(const T &value);
+    void insert(int pos, const T &value);
+    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
+    inline int firstIndex() const { return d->offset; }
+    inline int lastIndex() const { return d->offset + d->count - 1; }
+    inline const T &first() const { qt_noop(); return p->array[d->start]; }
+    inline const T &last() const { qt_noop(); return p->array[(d->start + d->count -1) % d->alloc]; }
+    inline T &first() { qt_noop(); detach(); return p->array[d->start]; }
+    inline T &last() { qt_noop(); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }
+    void removeFirst();
+    T takeFirst();
+    void removeLast();
+    T takeLast();
+    inline bool areIndexesValid() const
+    { return d->offset >= 0 && d->offset < 2147483647 - d->count && (d->offset % d->alloc) == d->start; }
+    inline void normalizeIndexes() { d->offset = d->start; }
+private:
+    void detach_helper();
+    QContiguousCacheData *malloc(int aalloc);
+    void free(Data *x);
+    int sizeOfTypedData() {
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+    int alignOfTypedData() const
+    {
+        return qMax<int>(sizeof(void*), __alignof__(Data));
+    }
+};
+template <typename T>
+void QContiguousCache<T>::detach_helper()
+{
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+    x.d = malloc(d->alloc);
+    x.d->ref = 1;
+    x.d->count = d->count;
+    x.d->start = d->start;
+    x.d->offset = d->offset;
+    x.d->alloc = d->alloc;
+    x.d->sharable = true;
+    x.d->reserved = 0;
+    T *dest = x.p->array + x.d->start;
+    T *src = p->array + d->start;
+    int oldcount = x.d->count;
+    while (oldcount--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        dest++;
+        if (dest == x.p->array + x.d->alloc)
+            dest = x.p->array;
+        src++;
+        if (src == p->array + d->alloc)
+            src = p->array;
+    }
+    if (!d->ref.deref())
+        free(p);
+    d = x.d;
+}
+template <typename T>
+void QContiguousCache<T>::setCapacity(int asize)
+{
+    if (asize == d->alloc)
+        return;
+    detach();
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+    x.d = malloc(asize);
+    x.d->alloc = asize;
+    x.d->count = qMin(d->count, asize);
+    x.d->offset = d->offset + d->count - x.d->count;
+    if(asize)
+        x.d->start = x.d->offset % x.d->alloc;
+    else
+        x.d->start = 0;
+    int oldcount = x.d->count;
+    if(oldcount)
+    {
+        T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
+        T *src = p->array + (d->start + d->count-1) % d->alloc;
+        while (oldcount--) {
+            if (QTypeInfo<T>::isComplex) {
+                new (dest) T(*src);
+            } else {
+                *dest = *src;
+            }
+            if (dest == x.p->array)
+                dest = x.p->array + x.d->alloc;
+            dest--;
+            if (src == p->array)
+                src = p->array + d->alloc;
+            src--;
+        }
+    }
+    free(p);
+    d = x.d;
+}
+template <typename T>
+void QContiguousCache<T>::clear()
+{
+    if (d->ref == 1) {
+        if (QTypeInfo<T>::isComplex) {
+            int oldcount = d->count;
+            T * i = p->array + d->start;
+            T * e = p->array + d->alloc;
+            while (oldcount--) {
+                i->~T();
+                i++;
+                if (i == e)
+                    i = p->array;
+            }
+        }
+        d->count = d->start = d->offset = 0;
+    } else {
+        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+        x.d = malloc(d->alloc);
+        x.d->ref = 1;
+        x.d->alloc = d->alloc;
+        x.d->count = x.d->start = x.d->offset = 0;
+        x.d->sharable = true;
+        if (!d->ref.deref()) free(p);
+        d = x.d;
+    }
+}
+template <typename T>
+inline QContiguousCacheData *QContiguousCache<T>::malloc(int aalloc)
+{
+    return QContiguousCacheData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
+}
+template <typename T>
+QContiguousCache<T>::QContiguousCache(int cap)
+{
+    d = malloc(cap);
+    d->ref = 1;
+    d->alloc = cap;
+    d->count = d->start = d->offset = 0;
+    d->sharable = true;
+}
+template <typename T>
+QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
+{
+    other.d->ref.ref();
+    if (!d->ref.deref())
+        free(d);
+    d = other.d;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+template <typename T>
+bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
+{
+    if (other.d == d)
+        return true;
+    if (other.d->start != d->start
+            || other.d->count != d->count
+            || other.d->offset != d->offset
+            || other.d->alloc != d->alloc)
+        return false;
+    for (int i = firstIndex(); i <= lastIndex(); ++i)
+        if (!(at(i) == other.at(i)))
+            return false;
+    return true;
+}
+template <typename T>
+void QContiguousCache<T>::free(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        int oldcount = d->count;
+        T * i = p->array + d->start;
+        T * e = p->array + d->alloc;
+        while (oldcount--) {
+            i->~T();
+            i++;
+            if (i == e)
+                i = p->array;
+        }
+    }
+    x->free(x);
+}
+template <typename T>
+void QContiguousCache<T>::append(const T &value)
+{
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        if (d->count == d->alloc)
+            (p->array + (d->start+d->count) % d->alloc)->~T();
+        new (p->array + (d->start+d->count) % d->alloc) T(value);
+    } else {
+        p->array[(d->start+d->count) % d->alloc] = value;
+    }
+    if (d->count == d->alloc) {
+        d->start++;
+        d->start %= d->alloc;
+        d->offset++;
+    } else {
+        d->count++;
+    }
+}
+template<typename T>
+void QContiguousCache<T>::prepend(const T &value)
+{
+    detach();
+    if (d->start)
+        d->start--;
+    else
+        d->start = d->alloc-1;
+    d->offset--;
+    if (d->count != d->alloc)
+        d->count++;
+    else
+        if (d->count == d->alloc)
+            (p->array + d->start)->~T();
+    if (QTypeInfo<T>::isComplex)
+        new (p->array + d->start) T(value);
+    else
+        p->array[d->start] = value;
+}
+template<typename T>
+void QContiguousCache<T>::insert(int pos, const T &value)
+{
+    qt_noop();
+    detach();
+    if (containsIndex(pos)) {
+        if (QTypeInfo<T>::isComplex) {
+            (p->array + pos % d->alloc)->~T();
+            new (p->array + pos % d->alloc) T(value);
+        } else {
+            p->array[pos % d->alloc] = value;
+        }
+    } else if (pos == d->offset-1)
+        prepend(value);
+    else if (pos == d->offset+d->count)
+        append(value);
+    else {
+        clear();
+        d->offset = pos;
+        d->start = pos % d->alloc;
+        d->count = 1;
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->start) T(value);
+        else
+            p->array[d->start] = value;
+    }
+}
+template <typename T>
+inline const T &QContiguousCache<T>::at(int pos) const
+{ qt_noop(); return p->array[pos % d->alloc]; }
+template <typename T>
+inline const T &QContiguousCache<T>::operator[](int pos) const
+{ qt_noop(); return p->array[pos % d->alloc]; }
+template <typename T>
+inline T &QContiguousCache<T>::operator[](int pos)
+{
+    detach();
+    if (!containsIndex(pos))
+        insert(pos, T());
+    return p->array[pos % d->alloc];
+}
+template <typename T>
+inline void QContiguousCache<T>::removeFirst()
+{
+    qt_noop();
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + d->start)->~T();
+    d->start = (d->start + 1) % d->alloc;
+    d->offset++;
+}
+template <typename T>
+inline void QContiguousCache<T>::removeLast()
+{
+    qt_noop();
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + (d->start + d->count) % d->alloc)->~T();
+}
+template <typename T>
+inline T QContiguousCache<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+template <typename T>
+inline T QContiguousCache<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QCryptographicHashPrivate;
+class QCryptographicHash
+{
+public:
+    enum Algorithm {
+        Md4,
+        Md5,
+        Sha1
+    };
+    QCryptographicHash(Algorithm method);
+    ~QCryptographicHash();
+    void reset();
+    void addData(const char *data, int length);
+    void addData(const QByteArray &data);
+    QByteArray result() const;
+    static QByteArray hash(const QByteArray &data, Algorithm method);
+private:
+    QCryptographicHash(const QCryptographicHash &); QCryptographicHash &operator=(const QCryptographicHash &);
+    QCryptographicHashPrivate *d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T> class QSharedDataPointer;
+class QSharedData
+{
+public:
+    mutable QAtomicInt ref;
+    inline QSharedData() : ref(0) { }
+    inline QSharedData(const QSharedData &) : ref(0) { }
+private:
+    QSharedData &operator=(const QSharedData &);
+};
+template <class T> class QSharedDataPointer
+{
+public:
+    typedef T Type;
+    typedef T *pointer;
+    inline void detach() { if (d && d->ref != 1) detach_helper(); }
+    inline T &operator*() { detach(); return *d; }
+    inline const T &operator*() const { return *d; }
+    inline T *operator->() { detach(); return d; }
+    inline const T *operator->() const { return d; }
+    inline operator T *() { detach(); return d; }
+    inline operator const T *() const { return d; }
+    inline T *data() { detach(); return d; }
+    inline const T *data() const { return d; }
+    inline const T *constData() const { return d; }
+    inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }
+    inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }
+    inline QSharedDataPointer() { d = 0; }
+    inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+    explicit QSharedDataPointer(T *data);
+    inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
+    inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {
+        if (o.d != d) {
+            if (o.d)
+                o.d->ref.ref();
+            T *old = d;
+            d = o.d;
+            if (old && !old->ref.deref())
+                delete old;
+        }
+        return *this;
+    }
+    inline QSharedDataPointer &operator=(T *o) {
+        if (o != d) {
+            if (o)
+                o->ref.ref();
+            T *old = d;
+            d = o;
+            if (old && !old->ref.deref())
+                delete old;
+        }
+        return *this;
+    }
+    inline bool operator!() const { return !d; }
+    inline void swap(QSharedDataPointer &other)
+    { qSwap(d, other.d); }
+protected:
+    T *clone();
+private:
+    void detach_helper();
+    T *d;
+};
+template <class T> class QExplicitlySharedDataPointer
+{
+public:
+    typedef T Type;
+    typedef T *pointer;
+    inline T &operator*() const { return *d; }
+    inline T *operator->() { return d; }
+    inline T *operator->() const { return d; }
+    inline T *data() const { return d; }
+    inline const T *constData() const { return d; }
+    inline void detach() { if (d && d->ref != 1) detach_helper(); }
+    inline void reset()
+    {
+        if(d && !d->ref.deref())
+            delete d;
+        d = 0;
+    }
+    inline operator bool () const { return d != 0; }
+    inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }
+    inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }
+    inline bool operator==(const T *ptr) const { return d == ptr; }
+    inline bool operator!=(const T *ptr) const { return d != ptr; }
+    inline QExplicitlySharedDataPointer() { d = 0; }
+    inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+    explicit QExplicitlySharedDataPointer(T *data);
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
+    template<class X>
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) : d(static_cast<T *>(o.data()))
+    {
+        if(d)
+            d->ref.ref();
+    }
+    inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {
+        if (o.d != d) {
+            if (o.d)
+                o.d->ref.ref();
+            T *old = d;
+            d = o.d;
+            if (old && !old->ref.deref())
+                delete old;
+        }
+        return *this;
+    }
+    inline QExplicitlySharedDataPointer &operator=(T *o) {
+        if (o != d) {
+            if (o)
+                o->ref.ref();
+            T *old = d;
+            d = o;
+            if (old && !old->ref.deref())
+                delete old;
+        }
+        return *this;
+    }
+    inline bool operator!() const { return !d; }
+    inline void swap(QExplicitlySharedDataPointer &other)
+    { qSwap(d, other.d); }
+protected:
+    T *clone();
+private:
+    void detach_helper();
+    T *d;
+};
+template <class T>
+inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) : d(adata)
+{ if (d) d->ref.ref(); }
+template <class T>
+inline T *QSharedDataPointer<T>::clone()
+{
+    return new T(*d);
+}
+template <class T>
+ void QSharedDataPointer<T>::detach_helper()
+{
+    T *x = clone();
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+template <class T>
+inline T *QExplicitlySharedDataPointer<T>::clone()
+{
+    return new T(*d);
+}
+template <class T>
+ void QExplicitlySharedDataPointer<T>::detach_helper()
+{
+    T *x = clone();
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+template <class T>
+inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) : d(adata)
+{ if (d) d->ref.ref(); }
+template <class T>
+inline void qSwap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
+{ p1.swap(p2); }
+template <class T>
+inline void qSwap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
+{ p1.swap(p2); }
+namespace std {
+    template <class T>
+    inline void swap(::QSharedDataPointer<T> &p1, ::QSharedDataPointer<T> &p2)
+    { p1.swap(p2); }
+    template <class T>
+    inline void swap(::QExplicitlySharedDataPointer<T> &p1, ::QExplicitlySharedDataPointer<T> &p2)
+    { p1.swap(p2); }
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T> class QWeakPointer;
+template <class T> class QSharedPointer;
+template <class X, class T>
+QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &ptr);
+template <class X, class T>
+QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &ptr);
+template <class X, class T>
+QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &ptr);
+template <class X, class T>
+QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &ptr);
+namespace QtSharedPointer {
+    template <class T> class InternalRefCount;
+    template <class T> class ExternalRefCount;
+    template <class X, class Y> QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
+    void internalSafetyCheckAdd2(const void *, const volatile void *);
+    void internalSafetyCheckRemove2(const void *);
+    template <class T, typename Klass, typename RetVal>
+    inline void executeDeleter(T *t, RetVal (Klass:: *memberDeleter)())
+    { (t->*memberDeleter)(); }
+    template <class T, typename Deleter>
+    inline void executeDeleter(T *t, Deleter d)
+    { d(t); }
+    template <class T> inline void normalDeleter(T *t) { delete t; }
+    template <class T> struct RemovePointer;
+    template <class T> struct RemovePointer<T *> { typedef T Type; };
+    template <class T> struct RemovePointer<QSharedPointer<T> > { typedef T Type; };
+    template <class T> struct RemovePointer<QWeakPointer<T> > { typedef T Type; };
+    template <class T>
+    class Basic
+    {
+        typedef T *Basic:: *RestrictedBool;
+    public:
+        typedef T Type;
+        typedef T element_type;
+        typedef T value_type;
+        typedef value_type *pointer;
+        typedef const value_type *const_pointer;
+        typedef value_type &reference;
+        typedef const value_type &const_reference;
+        typedef qptrdiff difference_type;
+        inline T *data() const { return value; }
+        inline bool isNull() const { return !data(); }
+        inline operator RestrictedBool() const { return isNull() ? 0 : &Basic::value; }
+        inline bool operator !() const { return isNull(); }
+        inline T &operator*() const { return *data(); }
+        inline T *operator->() const { return data(); }
+    protected:
+        inline Basic(T *ptr = 0) : value(ptr) { }
+        inline Basic(Qt::Initialization) { }
+        inline void internalConstruct(T *ptr)
+        {
+            value = ptr;
+        }
+        template <class X> friend class ::QWeakPointer;
+        Type *value;
+    };
+    struct ExternalRefCountData
+    {
+        QBasicAtomicInt weakref;
+        QBasicAtomicInt strongref;
+        inline ExternalRefCountData()
+        {
+            strongref = 1;
+            weakref = 1;
+        }
+        inline ExternalRefCountData(Qt::Initialization) { }
+        virtual inline ~ExternalRefCountData() { qt_noop(); qt_noop(); }
+        virtual inline bool destroy() { return false; }
+        static ExternalRefCountData *getAndRef(const QObject *);
+        void setQObjectShared(const QObject *, bool enable);
+        inline void setQObjectShared(...) { }
+    };
+    struct ExternalRefCountWithDestroyFn: public ExternalRefCountData
+    {
+        typedef void (*DestroyerFn)(ExternalRefCountData *);
+        DestroyerFn destroyer;
+        inline ExternalRefCountWithDestroyFn(DestroyerFn d)
+            : destroyer(d)
+        { }
+        inline bool destroy() { destroyer(this); return true; }
+        inline void operator delete(void *ptr) { ::operator delete(ptr); }
+        inline void operator delete(void *, void *) { }
+    };
+    template <class T, typename Deleter>
+    struct ExternalRefCountWithCustomDeleter: public ExternalRefCountWithDestroyFn
+    {
+        typedef ExternalRefCountWithCustomDeleter Self;
+        typedef ExternalRefCountWithDestroyFn BaseClass;
+        struct CustomDeleter
+        {
+            Deleter deleter;
+            T *ptr;
+            inline CustomDeleter(T *p, Deleter d) : deleter(d), ptr(p) {}
+        };
+        CustomDeleter extra;
+        static inline void deleter(ExternalRefCountData *self)
+        {
+            Self *realself = static_cast<Self *>(self);
+            executeDeleter(realself->extra.ptr, realself->extra.deleter);
+            realself->extra.~CustomDeleter();
+        }
+        static void safetyCheckDeleter(ExternalRefCountData *self)
+        {
+            internalSafetyCheckRemove2(self);
+            deleter(self);
+        }
+        static inline Self *create(T *ptr, Deleter userDeleter)
+        {
+            DestroyerFn destroy = &deleter;
+            Self *d = static_cast<Self *>(::operator new(sizeof(Self)));
+            new (&d->extra) CustomDeleter(ptr, userDeleter);
+            new (d) BaseClass(destroy);
+            return d;
+        }
+    private:
+        ExternalRefCountWithCustomDeleter();
+        ~ExternalRefCountWithCustomDeleter();
+    };
+    template <class T>
+    struct ExternalRefCountWithContiguousData: public ExternalRefCountWithDestroyFn
+    {
+        typedef ExternalRefCountWithDestroyFn Parent;
+        T data;
+        static void deleter(ExternalRefCountData *self)
+        {
+            ExternalRefCountWithContiguousData *that =
+                    static_cast<ExternalRefCountWithContiguousData *>(self);
+            that->data.~T();
+        }
+        static void safetyCheckDeleter(ExternalRefCountData *self)
+        {
+            internalSafetyCheckRemove2(self);
+            deleter(self);
+        }
+        static inline ExternalRefCountData *create(T **ptr)
+        {
+            DestroyerFn destroy = &deleter;
+            ExternalRefCountWithContiguousData *d =
+                static_cast<ExternalRefCountWithContiguousData *>(::operator new(sizeof(ExternalRefCountWithContiguousData)));
+            new (d) Parent(destroy);
+            *ptr = &d->data;
+            return d;
+        }
+    private:
+        ExternalRefCountWithContiguousData();
+        ~ExternalRefCountWithContiguousData();
+    };
+    template <class T>
+    class ExternalRefCount: public Basic<T>
+    {
+    protected:
+        typedef ExternalRefCountData Data;
+        inline void deref()
+        { deref(d, this->value); }
+        static inline void deref(Data *d, T *value)
+        {
+            if (!d) return;
+            if (!d->strongref.deref()) {
+                if (!d->destroy())
+                    delete value;
+            }
+            if (!d->weakref.deref())
+                delete d;
+        }
+        inline void internalConstruct(T *ptr)
+        {
+            if (ptr)
+                d = new Data;
+            else
+                d = 0;
+            internalFinishConstruction(ptr);
+        }
+        template <typename Deleter>
+        inline void internalConstruct(T *ptr, Deleter deleter)
+        {
+            if (ptr)
+                d = ExternalRefCountWithCustomDeleter<T, Deleter>::create(ptr, deleter);
+            else
+                d = 0;
+            internalFinishConstruction(ptr);
+        }
+        inline void internalCreate()
+        {
+            T *ptr;
+            d = ExternalRefCountWithContiguousData<T>::create(&ptr);
+            Basic<T>::internalConstruct(ptr);
+        }
+        inline void internalFinishConstruction(T *ptr)
+        {
+            Basic<T>::internalConstruct(ptr);
+            if (ptr) d->setQObjectShared(ptr, true);
+        }
+        inline ExternalRefCount() : d(0) { }
+        inline ExternalRefCount(Qt::Initialization i) : Basic<T>(i) { }
+        inline ExternalRefCount(T *ptr) : Basic<T>(Qt::Uninitialized)
+        { internalConstruct(ptr); }
+        template <typename Deleter>
+        inline ExternalRefCount(T *ptr, Deleter deleter) : Basic<T>(Qt::Uninitialized)
+        { internalConstruct(ptr, deleter); }
+        inline ExternalRefCount(const ExternalRefCount<T> &other) : Basic<T>(other), d(other.d)
+        { if (d) ref(); }
+        template <class X>
+        inline ExternalRefCount(const ExternalRefCount<X> &other) : Basic<T>(other.value), d(other.d)
+        { if (d) ref(); }
+        inline ~ExternalRefCount() { deref(); }
+        template <class X>
+        inline void internalCopy(const ExternalRefCount<X> &other)
+        {
+            Data *o = other.d;
+            T *actual = other.value;
+            if (o)
+                other.ref();
+            qSwap(d, o);
+            qSwap(this->value, actual);
+            deref(o, actual);
+        }
+        inline void internalSwap(ExternalRefCount &other)
+        {
+            qSwap(d, other.d);
+            qSwap(this->value, other.value);
+        }
+        template <class X> friend class ExternalRefCount;
+        template <class X> friend class ::QWeakPointer;
+        template <class X, class Y> friend QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
+        inline void ref() const { d->weakref.ref(); d->strongref.ref(); }
+        inline void internalSet(Data *o, T *actual)
+        {
+            if (o) {
+                register int tmp = o->strongref;
+                while (tmp > 0) {
+                    if (o->strongref.testAndSetRelaxed(tmp, tmp + 1))
+                        break;
+                    tmp = o->strongref;
+                }
+                if (tmp > 0)
+                    o->weakref.ref();
+                else
+                    o = 0;
+            }
+            qSwap(d, o);
+            qSwap(this->value, actual);
+            if (!d || d->strongref == 0)
+                this->value = 0;
+            deref(o, actual);
+        }
+        Data *d;
+    private:
+        template<class X> ExternalRefCount(const InternalRefCount<X> &);
+    };
+}
+template <class T>
+class QSharedPointer: public QtSharedPointer::ExternalRefCount<T>
+{
+    typedef typename QtSharedPointer::ExternalRefCount<T> BaseClass;
+public:
+    inline QSharedPointer() { }
+    inline explicit QSharedPointer(T *ptr) : BaseClass(ptr)
+    { }
+    template <typename Deleter>
+    inline QSharedPointer(T *ptr, Deleter d) : BaseClass(ptr, d)
+    { }
+    inline QSharedPointer(const QSharedPointer<T> &other) : BaseClass(other) { }
+    inline QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
+    {
+        BaseClass::internalCopy(other);
+        return *this;
+    }
+    template <class X>
+    inline QSharedPointer(const QSharedPointer<X> &other) : BaseClass(other)
+    { }
+    template <class X>
+    inline QSharedPointer<T> &operator=(const QSharedPointer<X> &other)
+    {
+        qt_noop();
+        BaseClass::internalCopy(other);
+        return *this;
+    }
+    template <class X>
+    inline QSharedPointer(const QWeakPointer<X> &other) : BaseClass(Qt::Uninitialized)
+    { this->d = 0; *this = other; }
+    template <class X>
+    inline QSharedPointer<T> &operator=(const QWeakPointer<X> &other)
+    { BaseClass::internalSet(other.d, other.value); return *this; }
+    inline void swap(QSharedPointer &other)
+    { QSharedPointer<T>::internalSwap(other); }
+    template <class X>
+    QSharedPointer<X> staticCast() const
+    {
+        return qSharedPointerCast<X, T>(*this);
+    }
+    template <class X>
+    QSharedPointer<X> dynamicCast() const
+    {
+        return qSharedPointerDynamicCast<X, T>(*this);
+    }
+    template <class X>
+    QSharedPointer<X> constCast() const
+    {
+        return qSharedPointerConstCast<X, T>(*this);
+    }
+    template <class X>
+    QSharedPointer<X> objectCast() const
+    {
+        return qSharedPointerObjectCast<X, T>(*this);
+    }
+    inline void clear() { *this = QSharedPointer<T>(); }
+    QWeakPointer<T> toWeakRef() const;
+protected:
+    inline explicit QSharedPointer(Qt::Initialization i) : BaseClass(i) {}
+public:
+    static inline QSharedPointer<T> create()
+    {
+        QSharedPointer<T> result(Qt::Uninitialized);
+        result.internalCreate();
+        new (result.data()) T();
+        result.internalFinishConstruction(result.data());
+        return result;
+    }
+};
+template <class T>
+class QWeakPointer
+{
+    typedef T *QWeakPointer:: *RestrictedBool;
+    typedef QtSharedPointer::ExternalRefCountData Data;
+public:
+    typedef T element_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    inline bool isNull() const { return d == 0 || d->strongref == 0 || value == 0; }
+    inline operator RestrictedBool() const { return isNull() ? 0 : &QWeakPointer::value; }
+    inline bool operator !() const { return isNull(); }
+    inline T *data() const { return d == 0 || d->strongref == 0 ? 0 : value; }
+    inline QWeakPointer() : d(0), value(0) { }
+    inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }
+    template <class X>
+    inline QWeakPointer(X *ptr) : d(ptr ? Data::getAndRef(ptr) : 0), value(ptr)
+    { }
+    template <class X>
+    inline QWeakPointer &operator=(X *ptr)
+    { return *this = QWeakPointer(ptr); }
+    inline QWeakPointer(const QWeakPointer<T> &o) : d(o.d), value(o.value)
+    { if (d) d->weakref.ref(); }
+    inline QWeakPointer<T> &operator=(const QWeakPointer<T> &o)
+    {
+        internalSet(o.d, o.value);
+        return *this;
+    }
+    inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
+    { if (d) d->weakref.ref();}
+    inline QWeakPointer<T> &operator=(const QSharedPointer<T> &o)
+    {
+        internalSet(o.d, o.value);
+        return *this;
+    }
+    template <class X>
+    inline QWeakPointer(const QWeakPointer<X> &o) : d(0), value(0)
+    { *this = o; }
+    template <class X>
+    inline QWeakPointer<T> &operator=(const QWeakPointer<X> &o)
+    {
+        *this = o.toStrongRef();
+        return *this;
+    }
+    template <class X>
+    inline bool operator==(const QWeakPointer<X> &o) const
+    { return d == o.d && value == static_cast<const T *>(o.value); }
+    template <class X>
+    inline bool operator!=(const QWeakPointer<X> &o) const
+    { return !(*this == o); }
+    template <class X>
+    inline QWeakPointer(const QSharedPointer<X> &o) : d(0), value(0)
+    { *this = o; }
+    template <class X>
+    inline QWeakPointer<T> &operator=(const QSharedPointer<X> &o)
+    {
+        qt_noop();
+        internalSet(o.d, o.data());
+        return *this;
+    }
+    template <class X>
+    inline bool operator==(const QSharedPointer<X> &o) const
+    { return d == o.d; }
+    template <class X>
+    inline bool operator!=(const QSharedPointer<X> &o) const
+    { return !(*this == o); }
+    inline void clear() { *this = QWeakPointer<T>(); }
+    inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }
+private:
+    template <class X> friend class QSharedPointer;
+    inline void internalSet(Data *o, T *actual)
+    {
+        if (d == o) return;
+        if (o)
+            o->weakref.ref();
+        if (d && !d->weakref.deref())
+            delete d;
+        d = o;
+        value = actual;
+    }
+    Data *d;
+    T *value;
+};
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() == ptr2.data();
+}
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() != ptr2.data();
+}
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)
+{
+    return ptr1.data() == ptr2;
+}
+template <class T, class X>
+bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1 == ptr2.data();
+}
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
+{
+    return !(ptr1 == ptr2);
+}
+template <class T, class X>
+bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return !(ptr2 == ptr1);
+}
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
+{
+    return ptr2 == ptr1;
+}
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
+{
+    return ptr2 != ptr1;
+}
+template <class T, class X>
+inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() - ptr2.data();
+}
+template <class T, class X>
+inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, X *ptr2)
+{
+    return ptr1.data() - ptr2;
+}
+template <class T, class X>
+inline typename QSharedPointer<X>::difference_type operator-(T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1 - ptr2.data();
+}
+template <class T, class X>
+inline bool operator<(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() < ptr2.data();
+}
+template <class T, class X>
+inline bool operator<(const QSharedPointer<T> &ptr1, X *ptr2)
+{
+    return ptr1.data() < ptr2;
+}
+template <class T, class X>
+inline bool operator<(T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1 < ptr2.data();
+}
+template <class T> inline uint qHash(const T *key);
+template <class T>
+inline uint qHash(const QSharedPointer<T> &ptr)
+{
+    return ::qHash<T>(ptr.data());
+}
+template <class T>
+inline QWeakPointer<T> QSharedPointer<T>::toWeakRef() const
+{
+    return QWeakPointer<T>(*this);
+}
+template <class T>
+inline void qSwap(QSharedPointer<T> &p1, QSharedPointer<T> &p2)
+{
+    p1.swap(p2);
+}
+namespace std {
+    template <class T>
+    inline void swap(::QSharedPointer<T> &p1, ::QSharedPointer<T> &p2)
+    { p1.swap(p2); }
+}
+namespace QtSharedPointer {
+    template <class X, class T>
+    inline QSharedPointer<X> copyAndSetPointer(X *ptr, const QSharedPointer<T> &src)
+    {
+        QSharedPointer<X> result;
+        result.internalSet(src.d, ptr);
+        return result;
+    }
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = static_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerCast<X, T>(src.toStrongRef());
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = dynamic_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerDynamicCast<X, T>(src.toStrongRef());
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = const_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerConstCast<X, T>(src.toStrongRef());
+}
+template <class X, class T>
+inline
+QWeakPointer<X> qWeakPointerCast(const QSharedPointer<T> &src)
+{
+    return qSharedPointerCast<X, T>(src).toWeakRef();
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = qobject_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerObjectCast<X>(src.toStrongRef());
+}
+template <class X, class T>
+inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
+qobject_cast(const QSharedPointer<T> &src)
+{
+    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
+}
+template <class X, class T>
+inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
+qobject_cast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
+}
+template<typename T> class QTypeInfo<QWeakPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QWeakPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QWeakPointer<T>"; } };
+template<typename T> class QTypeInfo<QSharedPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSharedPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSharedPointer<T>"; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDate
+{
+public:
+    enum MonthNameType {
+        DateFormat = 0,
+        StandaloneFormat
+    };
+public:
+    QDate() { jd = 0; }
+    QDate(int y, int m, int d);
+    bool isNull() const { return jd == 0; }
+    bool isValid() const;
+    int year() const;
+    int month() const;
+    int day() const;
+    int dayOfWeek() const;
+    int dayOfYear() const;
+    int daysInMonth() const;
+    int daysInYear() const;
+    int weekNumber(int *yearNum = 0) const;
+    static QString shortMonthName(int month);
+    static QString shortMonthName(int month, MonthNameType type);
+    static QString shortDayName(int weekday);
+    static QString shortDayName(int weekday, MonthNameType type);
+    static QString longMonthName(int month);
+    static QString longMonthName(int month, MonthNameType type);
+    static QString longDayName(int weekday);
+    static QString longDayName(int weekday, MonthNameType type);
+    QString toString(Qt::DateFormat f = Qt::TextDate) const;
+    QString toString(const QString &format) const;
+    bool setYMD(int y, int m, int d);
+    bool setDate(int year, int month, int day);
+    void getDate(int *year, int *month, int *day);
+    QDate addDays(int days) const;
+    QDate addMonths(int months) const;
+    QDate addYears(int years) const;
+    int daysTo(const QDate &) const;
+    bool operator==(const QDate &other) const { return jd == other.jd; }
+    bool operator!=(const QDate &other) const { return jd != other.jd; }
+    bool operator<(const QDate &other) const { return jd < other.jd; }
+    bool operator<=(const QDate &other) const { return jd <= other.jd; }
+    bool operator>(const QDate &other) const { return jd > other.jd; }
+    bool operator>=(const QDate &other) const { return jd >= other.jd; }
+    static QDate currentDate();
+    static QDate fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
+    static QDate fromString(const QString &s, const QString &format);
+    static bool isValid(int y, int m, int d);
+    static bool isLeapYear(int year);
+    static uint gregorianToJulian(int y, int m, int d);
+    static void julianToGregorian(uint jd, int &y, int &m, int &d);
+    static inline QDate fromJulianDay(int jd) { QDate d; d.jd = jd; return d; }
+    inline int toJulianDay() const { return jd; }
+private:
+    uint jd;
+    friend class QDateTime;
+    friend class QDateTimePrivate;
+    friend QDataStream &operator<<(QDataStream &, const QDate &);
+    friend QDataStream &operator>>(QDataStream &, QDate &);
+};
+template<> class QTypeInfo<QDate > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QDate)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QDate"; } };
+class QTime
+{
+public:
+    QTime(): mds(NullTime)
+    {}
+    QTime(int h, int m, int s = 0, int ms = 0);
+    bool isNull() const { return mds == NullTime; }
+    bool isValid() const;
+    int hour() const;
+    int minute() const;
+    int second() const;
+    int msec() const;
+    QString toString(Qt::DateFormat f = Qt::TextDate) const;
+    QString toString(const QString &format) const;
+    bool setHMS(int h, int m, int s, int ms = 0);
+    QTime addSecs(int secs) const;
+    int secsTo(const QTime &) const;
+    QTime addMSecs(int ms) const;
+    int msecsTo(const QTime &) const;
+    bool operator==(const QTime &other) const { return mds == other.mds; }
+    bool operator!=(const QTime &other) const { return mds != other.mds; }
+    bool operator<(const QTime &other) const { return mds < other.mds; }
+    bool operator<=(const QTime &other) const { return mds <= other.mds; }
+    bool operator>(const QTime &other) const { return mds > other.mds; }
+    bool operator>=(const QTime &other) const { return mds >= other.mds; }
+    static QTime currentTime();
+    static QTime fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
+    static QTime fromString(const QString &s, const QString &format);
+    static bool isValid(int h, int m, int s, int ms = 0);
+    void start();
+    int restart();
+    int elapsed() const;
+private:
+    enum TimeFlag { NullTime = -1 };
+    inline int ds() const { return mds == -1 ? 0 : mds; }
+    int mds;
+    friend class QDateTime;
+    friend class QDateTimePrivate;
+    friend QDataStream &operator<<(QDataStream &, const QTime &);
+    friend QDataStream &operator>>(QDataStream &, QTime &);
+};
+template<> class QTypeInfo<QTime > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTime)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTime"; } };
+class QDateTimePrivate;
+class QDateTime
+{
+public:
+    QDateTime();
+    explicit QDateTime(const QDate &);
+    QDateTime(const QDate &, const QTime &, Qt::TimeSpec spec = Qt::LocalTime);
+    QDateTime(const QDateTime &other);
+    ~QDateTime();
+    QDateTime &operator=(const QDateTime &other);
+    bool isNull() const;
+    bool isValid() const;
+    QDate date() const;
+    QTime time() const;
+    Qt::TimeSpec timeSpec() const;
+    qint64 toMSecsSinceEpoch() const;
+    uint toTime_t() const;
+    void setDate(const QDate &date);
+    void setTime(const QTime &time);
+    void setTimeSpec(Qt::TimeSpec spec);
+    void setMSecsSinceEpoch(qint64 msecs);
+    void setTime_t(uint secsSince1Jan1970UTC);
+    QString toString(Qt::DateFormat f = Qt::TextDate) const;
+    QString toString(const QString &format) const;
+    QDateTime addDays(int days) const;
+    QDateTime addMonths(int months) const;
+    QDateTime addYears(int years) const;
+    QDateTime addSecs(int secs) const;
+    QDateTime addMSecs(qint64 msecs) const;
+    QDateTime toTimeSpec(Qt::TimeSpec spec) const;
+    inline QDateTime toLocalTime() const { return toTimeSpec(Qt::LocalTime); }
+    inline QDateTime toUTC() const { return toTimeSpec(Qt::UTC); }
+    int daysTo(const QDateTime &) const;
+    int secsTo(const QDateTime &) const;
+    qint64 msecsTo(const QDateTime &) const;
+    bool operator==(const QDateTime &other) const;
+    inline bool operator!=(const QDateTime &other) const { return !(*this == other); }
+    bool operator<(const QDateTime &other) const;
+    inline bool operator<=(const QDateTime &other) const { return !(other < *this); }
+    inline bool operator>(const QDateTime &other) const { return other < *this; }
+    inline bool operator>=(const QDateTime &other) const { return !(*this < other); }
+    void setUtcOffset(int seconds);
+    int utcOffset() const;
+    static QDateTime currentDateTime();
+    static QDateTime currentDateTimeUtc();
+    static QDateTime fromString(const QString &s, Qt::DateFormat f = Qt::TextDate);
+    static QDateTime fromString(const QString &s, const QString &format);
+    static QDateTime fromTime_t(uint secsSince1Jan1970UTC);
+    static QDateTime fromMSecsSinceEpoch(qint64 msecs);
+    static qint64 currentMSecsSinceEpoch();
+private:
+    friend class QDateTimePrivate;
+    void detach();
+    QExplicitlySharedDataPointer<QDateTimePrivate> d;
+    friend QDataStream &operator<<(QDataStream &, const QDateTime &);
+    friend QDataStream &operator>>(QDataStream &, QDateTime &);
+};
+template<> class QTypeInfo<QDateTime > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QDateTime)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QDateTime"; } };
+ QDataStream &operator<<(QDataStream &, const QDate &);
+ QDataStream &operator>>(QDataStream &, QDate &);
+ QDataStream &operator<<(QDataStream &, const QTime &);
+ QDataStream &operator>>(QDataStream &, QTime &);
+ QDataStream &operator<<(QDataStream &, const QDateTime &);
+ QDataStream &operator>>(QDataStream &, QDateTime &);
+ QDebug operator<<(QDebug, const QDate &);
+ QDebug operator<<(QDebug, const QTime &);
+ QDebug operator<<(QDebug, const QDateTime &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEasingCurvePrivate;
+class QEasingCurve
+{
+    public: static const QMetaObject staticMetaObject; private:
+public:
+    enum Type {
+        Linear,
+        InQuad, OutQuad, InOutQuad, OutInQuad,
+        InCubic, OutCubic, InOutCubic, OutInCubic,
+        InQuart, OutQuart, InOutQuart, OutInQuart,
+        InQuint, OutQuint, InOutQuint, OutInQuint,
+        InSine, OutSine, InOutSine, OutInSine,
+        InExpo, OutExpo, InOutExpo, OutInExpo,
+        InCirc, OutCirc, InOutCirc, OutInCirc,
+        InElastic, OutElastic, InOutElastic, OutInElastic,
+        InBack, OutBack, InOutBack, OutInBack,
+        InBounce, OutBounce, InOutBounce, OutInBounce,
+        InCurve, OutCurve, SineCurve, CosineCurve,
+        Custom, NCurveTypes
+    };
+    QEasingCurve(Type type = Linear);
+    QEasingCurve(const QEasingCurve &other);
+    ~QEasingCurve();
+    QEasingCurve &operator=(const QEasingCurve &other);
+    bool operator==(const QEasingCurve &other) const;
+    inline bool operator!=(const QEasingCurve &other) const
+    { return !(this->operator==(other)); }
+    qreal amplitude() const;
+    void setAmplitude(qreal amplitude);
+    qreal period() const;
+    void setPeriod(qreal period);
+    qreal overshoot() const;
+    void setOvershoot(qreal overshoot);
+    Type type() const;
+    void setType(Type type);
+    typedef qreal (*EasingFunction)(qreal progress);
+    void setCustomType(EasingFunction func);
+    EasingFunction customType() const;
+    qreal valueForProgress(qreal progress) const;
+private:
+    QEasingCurvePrivate *d_ptr;
+    friend QDebug operator<<(QDebug debug, const QEasingCurve &item);
+    friend QDataStream &operator<<(QDataStream &, const QEasingCurve&);
+    friend QDataStream &operator>>(QDataStream &, QEasingCurve &);
+};
+ QDebug operator<<(QDebug debug, const QEasingCurve &item);
+ QDataStream &operator<<(QDataStream &, const QEasingCurve&);
+ QDataStream &operator>>(QDataStream &, QEasingCurve &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QElapsedTimer
+{
+public:
+    enum ClockType {
+        SystemTime,
+        MonotonicClock,
+        TickCounter,
+        MachAbsoluteTime,
+        PerformanceCounter
+    };
+    static ClockType clockType();
+    static bool isMonotonic();
+    void start();
+    qint64 restart();
+    void invalidate();
+    bool isValid() const;
+    qint64 nsecsElapsed() const;
+    qint64 elapsed() const;
+    bool hasExpired(qint64 timeout) const;
+    qint64 msecsSinceReference() const;
+    qint64 msecsTo(const QElapsedTimer &other) const;
+    qint64 secsTo(const QElapsedTimer &other) const;
+    bool operator==(const QElapsedTimer &other) const
+    { return t1 == other.t1 && t2 == other.t2; }
+    bool operator!=(const QElapsedTimer &other) const
+    { return !(*this == other); }
+    friend bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2);
+private:
+    qint64 t1;
+    qint64 t2;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QPoint
+{
+public:
+    QPoint();
+    QPoint(int xpos, int ypos);
+    bool isNull() const;
+    int x() const;
+    int y() const;
+    void setX(int x);
+    void setY(int y);
+    int manhattanLength() const;
+    int &rx();
+    int &ry();
+    QPoint &operator+=(const QPoint &p);
+    QPoint &operator-=(const QPoint &p);
+    QPoint &operator*=(float c);
+    QPoint &operator*=(double c);
+    QPoint &operator*=(int c);
+    QPoint &operator/=(qreal c);
+    friend inline bool operator==(const QPoint &, const QPoint &);
+    friend inline bool operator!=(const QPoint &, const QPoint &);
+    friend inline const QPoint operator+(const QPoint &, const QPoint &);
+    friend inline const QPoint operator-(const QPoint &, const QPoint &);
+    friend inline const QPoint operator*(const QPoint &, float);
+    friend inline const QPoint operator*(float, const QPoint &);
+    friend inline const QPoint operator*(const QPoint &, double);
+    friend inline const QPoint operator*(double, const QPoint &);
+    friend inline const QPoint operator*(const QPoint &, int);
+    friend inline const QPoint operator*(int, const QPoint &);
+    friend inline const QPoint operator-(const QPoint &);
+    friend inline const QPoint operator/(const QPoint &, qreal);
+private:
+    friend class QTransform;
+    int xp;
+    int yp;
+};
+template<> class QTypeInfo<QPoint > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPoint"; } };
+ QDataStream &operator<<(QDataStream &, const QPoint &);
+ QDataStream &operator>>(QDataStream &, QPoint &);
+inline QPoint::QPoint()
+{ xp=0; yp=0; }
+inline QPoint::QPoint(int xpos, int ypos)
+{ xp = xpos; yp = ypos; }
+inline bool QPoint::isNull() const
+{ return xp == 0 && yp == 0; }
+inline int QPoint::x() const
+{ return xp; }
+inline int QPoint::y() const
+{ return yp; }
+inline void QPoint::setX(int xpos)
+{ xp = xpos; }
+inline void QPoint::setY(int ypos)
+{ yp = ypos; }
+inline int &QPoint::rx()
+{ return xp; }
+inline int &QPoint::ry()
+{ return yp; }
+inline QPoint &QPoint::operator+=(const QPoint &p)
+{ xp+=p.xp; yp+=p.yp; return *this; }
+inline QPoint &QPoint::operator-=(const QPoint &p)
+{ xp-=p.xp; yp-=p.yp; return *this; }
+inline QPoint &QPoint::operator*=(float c)
+{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; }
+inline QPoint &QPoint::operator*=(double c)
+{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; }
+inline QPoint &QPoint::operator*=(int c)
+{ xp = xp*c; yp = yp*c; return *this; }
+inline bool operator==(const QPoint &p1, const QPoint &p2)
+{ return p1.xp == p2.xp && p1.yp == p2.yp; }
+inline bool operator!=(const QPoint &p1, const QPoint &p2)
+{ return p1.xp != p2.xp || p1.yp != p2.yp; }
+inline const QPoint operator+(const QPoint &p1, const QPoint &p2)
+{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }
+inline const QPoint operator-(const QPoint &p1, const QPoint &p2)
+{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }
+inline const QPoint operator*(const QPoint &p, float c)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+inline const QPoint operator*(const QPoint &p, double c)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+inline const QPoint operator*(const QPoint &p, int c)
+{ return QPoint(p.xp*c, p.yp*c); }
+inline const QPoint operator*(float c, const QPoint &p)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+inline const QPoint operator*(double c, const QPoint &p)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+inline const QPoint operator*(int c, const QPoint &p)
+{ return QPoint(p.xp*c, p.yp*c); }
+inline const QPoint operator-(const QPoint &p)
+{ return QPoint(-p.xp, -p.yp); }
+inline QPoint &QPoint::operator/=(qreal c)
+{
+    xp = qRound(xp/c);
+    yp = qRound(yp/c);
+    return *this;
+}
+inline const QPoint operator/(const QPoint &p, qreal c)
+{
+    return QPoint(qRound(p.xp/c), qRound(p.yp/c));
+}
+ QDebug operator<<(QDebug, const QPoint &);
+class QPointF
+{
+public:
+    QPointF();
+    QPointF(const QPoint &p);
+    QPointF(qreal xpos, qreal ypos);
+    qreal manhattanLength() const;
+    bool isNull() const;
+    qreal x() const;
+    qreal y() const;
+    void setX(qreal x);
+    void setY(qreal y);
+    qreal &rx();
+    qreal &ry();
+    QPointF &operator+=(const QPointF &p);
+    QPointF &operator-=(const QPointF &p);
+    QPointF &operator*=(qreal c);
+    QPointF &operator/=(qreal c);
+    friend inline bool operator==(const QPointF &, const QPointF &);
+    friend inline bool operator!=(const QPointF &, const QPointF &);
+    friend inline const QPointF operator+(const QPointF &, const QPointF &);
+    friend inline const QPointF operator-(const QPointF &, const QPointF &);
+    friend inline const QPointF operator*(qreal, const QPointF &);
+    friend inline const QPointF operator*(const QPointF &, qreal);
+    friend inline const QPointF operator-(const QPointF &);
+    friend inline const QPointF operator/(const QPointF &, qreal);
+    QPoint toPoint() const;
+private:
+    friend class QMatrix;
+    friend class QTransform;
+    qreal xp;
+    qreal yp;
+};
+template<> class QTypeInfo<QPointF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPointF"; } };
+ QDataStream &operator<<(QDataStream &, const QPointF &);
+ QDataStream &operator>>(QDataStream &, QPointF &);
+inline QPointF::QPointF() : xp(0), yp(0) { }
+inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { }
+inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { }
+inline bool QPointF::isNull() const
+{
+    return qIsNull(xp) && qIsNull(yp);
+}
+inline qreal QPointF::x() const
+{
+    return xp;
+}
+inline qreal QPointF::y() const
+{
+    return yp;
+}
+inline void QPointF::setX(qreal xpos)
+{
+    xp = xpos;
+}
+inline void QPointF::setY(qreal ypos)
+{
+    yp = ypos;
+}
+inline qreal &QPointF::rx()
+{
+    return xp;
+}
+inline qreal &QPointF::ry()
+{
+    return yp;
+}
+inline QPointF &QPointF::operator+=(const QPointF &p)
+{
+    xp+=p.xp;
+    yp+=p.yp;
+    return *this;
+}
+inline QPointF &QPointF::operator-=(const QPointF &p)
+{
+    xp-=p.xp; yp-=p.yp; return *this;
+}
+inline QPointF &QPointF::operator*=(qreal c)
+{
+    xp*=c; yp*=c; return *this;
+}
+inline bool operator==(const QPointF &p1, const QPointF &p2)
+{
+    return qFuzzyIsNull(p1.xp - p2.xp) && qFuzzyIsNull(p1.yp - p2.yp);
+}
+inline bool operator!=(const QPointF &p1, const QPointF &p2)
+{
+    return !qFuzzyIsNull(p1.xp - p2.xp) || !qFuzzyIsNull(p1.yp - p2.yp);
+}
+inline const QPointF operator+(const QPointF &p1, const QPointF &p2)
+{
+    return QPointF(p1.xp+p2.xp, p1.yp+p2.yp);
+}
+inline const QPointF operator-(const QPointF &p1, const QPointF &p2)
+{
+    return QPointF(p1.xp-p2.xp, p1.yp-p2.yp);
+}
+inline const QPointF operator*(const QPointF &p, qreal c)
+{
+    return QPointF(p.xp*c, p.yp*c);
+}
+inline const QPointF operator*(qreal c, const QPointF &p)
+{
+    return QPointF(p.xp*c, p.yp*c);
+}
+inline const QPointF operator-(const QPointF &p)
+{
+    return QPointF(-p.xp, -p.yp);
+}
+inline QPointF &QPointF::operator/=(qreal c)
+{
+    xp/=c;
+    yp/=c;
+    return *this;
+}
+inline const QPointF operator/(const QPointF &p, qreal c)
+{
+    return QPointF(p.xp/c, p.yp/c);
+}
+inline QPoint QPointF::toPoint() const
+{
+    return QPoint(qRound(xp), qRound(yp));
+}
+ QDebug operator<<(QDebug d, const QPointF &p);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLine
+{
+public:
+    inline QLine();
+    inline QLine(const QPoint &pt1, const QPoint &pt2);
+    inline QLine(int x1, int y1, int x2, int y2);
+    inline bool isNull() const;
+    inline QPoint p1() const;
+    inline QPoint p2() const;
+    inline int x1() const;
+    inline int y1() const;
+    inline int x2() const;
+    inline int y2() const;
+    inline int dx() const;
+    inline int dy() const;
+    inline void translate(const QPoint &p);
+    inline void translate(int dx, int dy);
+    inline QLine translated(const QPoint &p) const;
+    inline QLine translated(int dx, int dy) const;
+    inline void setP1(const QPoint &p1);
+    inline void setP2(const QPoint &p2);
+    inline void setPoints(const QPoint &p1, const QPoint &p2);
+    inline void setLine(int x1, int y1, int x2, int y2);
+    inline bool operator==(const QLine &d) const;
+    inline bool operator!=(const QLine &d) const { return !(*this == d); }
+private:
+    QPoint pt1, pt2;
+};
+template<> class QTypeInfo<QLine > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLine"; } };
+inline QLine::QLine() { }
+inline QLine::QLine(const QPoint &pt1_, const QPoint &pt2_) : pt1(pt1_), pt2(pt2_) { }
+inline QLine::QLine(int x1pos, int y1pos, int x2pos, int y2pos) : pt1(QPoint(x1pos, y1pos)), pt2(QPoint(x2pos, y2pos)) { }
+inline bool QLine::isNull() const
+{
+    return pt1 == pt2;
+}
+inline int QLine::x1() const
+{
+    return pt1.x();
+}
+inline int QLine::y1() const
+{
+    return pt1.y();
+}
+inline int QLine::x2() const
+{
+    return pt2.x();
+}
+inline int QLine::y2() const
+{
+    return pt2.y();
+}
+inline QPoint QLine::p1() const
+{
+    return pt1;
+}
+inline QPoint QLine::p2() const
+{
+    return pt2;
+}
+inline int QLine::dx() const
+{
+    return pt2.x() - pt1.x();
+}
+inline int QLine::dy() const
+{
+    return pt2.y() - pt1.y();
+}
+inline void QLine::translate(const QPoint &point)
+{
+    pt1 += point;
+    pt2 += point;
+}
+inline void QLine::translate(int adx, int ady)
+{
+    this->translate(QPoint(adx, ady));
+}
+inline QLine QLine::translated(const QPoint &p) const
+{
+    return QLine(pt1 + p, pt2 + p);
+}
+inline QLine QLine::translated(int adx, int ady) const
+{
+    return translated(QPoint(adx, ady));
+}
+inline void QLine::setP1(const QPoint &aP1)
+{
+    pt1 = aP1;
+}
+inline void QLine::setP2(const QPoint &aP2)
+{
+    pt2 = aP2;
+}
+inline void QLine::setPoints(const QPoint &aP1, const QPoint &aP2)
+{
+    pt1 = aP1;
+    pt2 = aP2;
+}
+inline void QLine::setLine(int aX1, int aY1, int aX2, int aY2)
+{
+    pt1 = QPoint(aX1, aY1);
+    pt2 = QPoint(aX2, aY2);
+}
+inline bool QLine::operator==(const QLine &d) const
+{
+    return pt1 == d.pt1 && pt2 == d.pt2;
+}
+ QDebug operator<<(QDebug d, const QLine &p);
+ QDataStream &operator<<(QDataStream &, const QLine &);
+ QDataStream &operator>>(QDataStream &, QLine &);
+class QLineF {
+public:
+    enum IntersectType { NoIntersection, BoundedIntersection, UnboundedIntersection };
+    inline QLineF();
+    inline QLineF(const QPointF &pt1, const QPointF &pt2);
+    inline QLineF(qreal x1, qreal y1, qreal x2, qreal y2);
+    inline QLineF(const QLine &line) : pt1(line.p1()), pt2(line.p2()) { }
+    static QLineF fromPolar(qreal length, qreal angle);
+    bool isNull() const;
+    inline QPointF p1() const;
+    inline QPointF p2() const;
+    inline qreal x1() const;
+    inline qreal y1() const;
+    inline qreal x2() const;
+    inline qreal y2() const;
+    inline qreal dx() const;
+    inline qreal dy() const;
+    qreal length() const;
+    void setLength(qreal len);
+    qreal angle() const;
+    void setAngle(qreal angle);
+    qreal angleTo(const QLineF &l) const;
+    QLineF unitVector() const;
+    QLineF normalVector() const;
+    IntersectType intersect(const QLineF &l, QPointF *intersectionPoint) const;
+    qreal angle(const QLineF &l) const;
+    QPointF pointAt(qreal t) const;
+    inline void translate(const QPointF &p);
+    inline void translate(qreal dx, qreal dy);
+    inline QLineF translated(const QPointF &p) const;
+    inline QLineF translated(qreal dx, qreal dy) const;
+    inline void setP1(const QPointF &p1);
+    inline void setP2(const QPointF &p2);
+    inline void setPoints(const QPointF &p1, const QPointF &p2);
+    inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2);
+    inline bool operator==(const QLineF &d) const;
+    inline bool operator!=(const QLineF &d) const { return !(*this == d); }
+    QLine toLine() const;
+private:
+    QPointF pt1, pt2;
+};
+template<> class QTypeInfo<QLineF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLineF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLineF"; } };
+inline QLineF::QLineF()
+{
+}
+inline QLineF::QLineF(const QPointF &apt1, const QPointF &apt2)
+    : pt1(apt1), pt2(apt2)
+{
+}
+inline QLineF::QLineF(qreal x1pos, qreal y1pos, qreal x2pos, qreal y2pos)
+    : pt1(x1pos, y1pos), pt2(x2pos, y2pos)
+{
+}
+inline qreal QLineF::x1() const
+{
+    return pt1.x();
+}
+inline qreal QLineF::y1() const
+{
+    return pt1.y();
+}
+inline qreal QLineF::x2() const
+{
+    return pt2.x();
+}
+inline qreal QLineF::y2() const
+{
+    return pt2.y();
+}
+inline QPointF QLineF::p1() const
+{
+    return pt1;
+}
+inline QPointF QLineF::p2() const
+{
+    return pt2;
+}
+inline qreal QLineF::dx() const
+{
+    return pt2.x() - pt1.x();
+}
+inline qreal QLineF::dy() const
+{
+    return pt2.y() - pt1.y();
+}
+inline QLineF QLineF::normalVector() const
+{
+    return QLineF(p1(), p1() + QPointF(dy(), -dx()));
+}
+inline void QLineF::translate(const QPointF &point)
+{
+    pt1 += point;
+    pt2 += point;
+}
+inline void QLineF::translate(qreal adx, qreal ady)
+{
+    this->translate(QPointF(adx, ady));
+}
+inline QLineF QLineF::translated(const QPointF &p) const
+{
+    return QLineF(pt1 + p, pt2 + p);
+}
+inline QLineF QLineF::translated(qreal adx, qreal ady) const
+{
+    return translated(QPointF(adx, ady));
+}
+inline void QLineF::setLength(qreal len)
+{
+    if (isNull())
+        return;
+    QLineF v = unitVector();
+    pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len);
+}
+inline QPointF QLineF::pointAt(qreal t) const
+{
+    qreal vx = pt2.x() - pt1.x();
+    qreal vy = pt2.y() - pt1.y();
+    return QPointF(pt1.x() + vx * t, pt1.y() + vy * t);
+}
+inline QLine QLineF::toLine() const
+{
+    return QLine(pt1.toPoint(), pt2.toPoint());
+}
+inline void QLineF::setP1(const QPointF &aP1)
+{
+    pt1 = aP1;
+}
+inline void QLineF::setP2(const QPointF &aP2)
+{
+    pt2 = aP2;
+}
+inline void QLineF::setPoints(const QPointF &aP1, const QPointF &aP2)
+{
+    pt1 = aP1;
+    pt2 = aP2;
+}
+inline void QLineF::setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2)
+{
+    pt1 = QPointF(aX1, aY1);
+    pt2 = QPointF(aX2, aY2);
+}
+inline bool QLineF::operator==(const QLineF &d) const
+{
+    return pt1 == d.pt1 && pt2 == d.pt2;
+}
+ QDebug operator<<(QDebug d, const QLineF &p);
+ QDataStream &operator<<(QDataStream &, const QLineF &);
+ QDataStream &operator>>(QDataStream &, QLineF &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QLinkedListData
+{
+    QLinkedListData *n, *p;
+    QBasicAtomicInt ref;
+    int size;
+    uint sharable : 1;
+    static QLinkedListData shared_null;
+};
+template <typename T>
+struct QLinkedListNode
+{
+    inline QLinkedListNode(const T &arg): t(arg) { }
+    QLinkedListNode *n, *p;
+    T t;
+};
+template <class T>
+class QLinkedList
+{
+    typedef QLinkedListNode<T> Node;
+    union { QLinkedListData *d; QLinkedListNode<T> *e; };
+public:
+    inline QLinkedList() : d(&QLinkedListData::shared_null) { d->ref.ref(); }
+    inline QLinkedList(const QLinkedList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach(); }
+    ~QLinkedList();
+    QLinkedList<T> &operator=(const QLinkedList<T> &);
+    inline void swap(QLinkedList<T> &other) { qSwap(d, other.d); }
+    bool operator==(const QLinkedList<T> &l) const;
+    inline bool operator!=(const QLinkedList<T> &l) const { return !(*this == l); }
+    inline int size() const { return d->size; }
+    inline void detach()
+    { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline bool isSharedWith(const QLinkedList<T> &other) const { return d == other.d; }
+    inline bool isEmpty() const { return d->size == 0; }
+    void clear();
+    void append(const T &);
+    void prepend(const T &);
+    T takeFirst();
+    T takeLast();
+    int removeAll(const T &t);
+    bool removeOne(const T &t);
+    bool contains(const T &t) const;
+    int count(const T &t) const;
+    class const_iterator;
+    class iterator
+    {
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+        Node *i;
+        inline iterator() : i(0) {}
+        inline iterator(Node *n) : i(n) {}
+        inline iterator(const iterator &o) : i(o.i) {}
+        inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
+        inline T &operator*() const { return i->t; }
+        inline T *operator->() const { return &i->t; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline iterator &operator++() { i = i->n; return *this; }
+        inline iterator operator++(int) { Node *n = i; i = i->n; return n; }
+        inline iterator &operator--() { i = i->p; return *this; }
+        inline iterator operator--(int) { Node *n = i; i = i->p; return n; }
+        inline iterator operator+(int j) const
+        { Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { return *this = *this + j; }
+        inline iterator &operator-=(int j) { return *this = *this - j; }
+    };
+    friend class iterator;
+    class const_iterator
+    {
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        Node *i;
+        inline const_iterator() : i(0) {}
+        inline const_iterator(Node *n) : i(n) {}
+        inline const_iterator(const const_iterator &o) : i(o.i){}
+        inline const_iterator(iterator ci) : i(ci.i){}
+ inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i->t; }
+        inline const T *operator->() const { return &i->t; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() { i = i->n; return *this; }
+        inline const_iterator operator++(int) { Node *n = i; i = i->n; return n; }
+        inline const_iterator &operator--() { i = i->p; return *this; }
+        inline const_iterator operator--(int) { Node *n = i; i = i->p; return n; }
+        inline const_iterator operator+(int j) const
+        { Node *n = i; if (j > 0) while (j--) n = n->n; else while (j++) n = n->p; return n; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { return *this = *this + j; }
+        inline const_iterator &operator-=(int j) { return *this = *this - j; }
+    };
+    friend class const_iterator;
+    inline iterator begin() { detach(); return e->n; }
+    inline const_iterator begin() const { return e->n; }
+    inline const_iterator constBegin() const { return e->n; }
+    inline iterator end() { detach(); return e; }
+    inline const_iterator end() const { return e; }
+    inline const_iterator constEnd() const { return e; }
+    iterator insert(iterator before, const T &t);
+    iterator erase(iterator pos);
+    iterator erase(iterator first, iterator last);
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    inline T& first() { qt_noop(); return *begin(); }
+    inline const T& first() const { qt_noop(); return *begin(); }
+    T& last() { qt_noop(); return *(--end()); }
+    const T& last() const { qt_noop(); return *(--end()); }
+    inline void removeFirst() { qt_noop(); erase(begin()); }
+    inline void removeLast() { qt_noop(); erase(--end()); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    inline T& front() { return first(); }
+    inline const T& front() const { return first(); }
+    inline T& back() { return last(); }
+    inline const T& back() const { return last(); }
+    inline void pop_front() { removeFirst(); }
+    inline void pop_back() { removeLast(); }
+    inline bool empty() const { return isEmpty(); }
+    typedef int size_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    static inline QLinkedList<T> fromStdList(const std::list<T> &list)
+    { QLinkedList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::list<T> toStdList() const
+    { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
+    QLinkedList<T> &operator+=(const QLinkedList<T> &l);
+    QLinkedList<T> operator+(const QLinkedList<T> &l) const;
+    inline QLinkedList<T> &operator+=(const T &t) { append(t); return *this; }
+    inline QLinkedList<T> &operator<< (const T &t) { append(t); return *this; }
+    inline QLinkedList<T> &operator<<(const QLinkedList<T> &l) { *this += l; return *this; }
+private:
+    void detach_helper();
+    void free(QLinkedListData*);
+};
+template <typename T>
+inline QLinkedList<T>::~QLinkedList()
+{
+    if (!d)
+        return;
+    if (!d->ref.deref())
+        free(d);
+}
+template <typename T>
+void QLinkedList<T>::detach_helper()
+{
+    union { QLinkedListData *d; Node *e; } x;
+    x.d = new QLinkedListData;
+    x.d->ref = 1;
+    x.d->size = d->size;
+    x.d->sharable = true;
+    Node *original = e->n;
+    Node *copy = x.e;
+    while (original != e) {
+        try {
+            copy->n = new Node(original->t);
+            copy->n->p = copy;
+            original = original->n;
+            copy = copy->n;
+        } catch (...) {
+            copy->n = x.e;
+            free(x.d);
+            throw;
+        }
+    }
+    copy->n = x.e;
+    x.e->p = copy;
+    if (!d->ref.deref())
+        free(d);
+    d = x.d;
+}
+template <typename T>
+void QLinkedList<T>::free(QLinkedListData *x)
+{
+    Node *y = reinterpret_cast<Node*>(x);
+    Node *i = y->n;
+    if (x->ref == 0) {
+        while(i != y) {
+            Node *n = i;
+            i = i->n;
+            delete n;
+        }
+        delete x;
+    }
+}
+template <typename T>
+void QLinkedList<T>::clear()
+{
+    *this = QLinkedList<T>();
+}
+template <typename T>
+QLinkedList<T> &QLinkedList<T>::operator=(const QLinkedList<T> &l)
+{
+    if (d != l.d) {
+        QLinkedListData *o = l.d;
+        o->ref.ref();
+        if (!d->ref.deref())
+            free(d);
+        d = o;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+template <typename T>
+bool QLinkedList<T>::operator== (const QLinkedList<T> &l) const
+{
+    if (d->size != l.d->size)
+        return false;
+    if (e == l.e)
+        return true;
+    Node *i = e->n;
+    Node *il = l.e->n;
+    while (i != e) {
+        if (! (i->t == il->t))
+            return false;
+        i = i->n;
+        il = il->n;
+    }
+    return true;
+}
+template <typename T>
+void QLinkedList<T>::append(const T &t)
+{
+    detach();
+    Node *i = new Node(t);
+    i->n = e;
+    i->p = e->p;
+    i->p->n = i;
+    e->p = i;
+    d->size++;
+}
+template <typename T>
+void QLinkedList<T>::prepend(const T &t)
+{
+    detach();
+    Node *i = new Node(t);
+    i->n = e->n;
+    i->p = e;
+    i->n->p = i;
+    e->n = i;
+    d->size++;
+}
+template <typename T>
+int QLinkedList<T>::removeAll(const T &_t)
+{
+    detach();
+    const T t = _t;
+    Node *i = e->n;
+    int c = 0;
+    while (i != e) {
+        if (i->t == t) {
+            Node *n = i;
+            i->n->p = i->p;
+            i->p->n = i->n;
+            i = i->n;
+            delete n;
+            c++;
+        } else {
+            i = i->n;
+        }
+    }
+    d->size-=c;
+    return c;
+}
+template <typename T>
+bool QLinkedList<T>::removeOne(const T &_t)
+{
+    detach();
+    iterator it = qFind(begin(), end(), _t);
+    if (it != end()) {
+        erase(it);
+        return true;
+    }
+    return false;
+}
+template <typename T>
+inline T QLinkedList<T>::takeFirst()
+{
+    T t = first();
+    removeFirst();
+    return t;
+}
+template <typename T>
+inline T QLinkedList<T>::takeLast()
+{
+    T t = last();
+    removeLast();
+    return t;
+}
+template <typename T>
+bool QLinkedList<T>::contains(const T &t) const
+{
+    Node *i = e;
+    while ((i = i->n) != e)
+        if (i->t == t)
+            return true;
+    return false;
+}
+template <typename T>
+int QLinkedList<T>::count(const T &t) const
+{
+    Node *i = e;
+    int c = 0;
+    while ((i = i->n) != e)
+        if (i->t == t)
+            c++;
+    return c;
+}
+template <typename T>
+typename QLinkedList<T>::iterator QLinkedList<T>::insert(iterator before, const T &t)
+{
+    Node *i = before.i;
+    Node *m = new Node(t);
+    m->n = i;
+    m->p = i->p;
+    m->p->n = m;
+    i->p = m;
+    d->size++;
+    return m;
+}
+template <typename T>
+typename QLinkedList<T>::iterator QLinkedList<T>::erase(typename QLinkedList<T>::iterator afirst,
+                                                         typename QLinkedList<T>::iterator alast)
+{
+    while (afirst != alast)
+        erase(afirst++);
+    return alast;
+}
+template <typename T>
+typename QLinkedList<T>::iterator QLinkedList<T>::erase(iterator pos)
+{
+    detach();
+    Node *i = pos.i;
+    if (i != e) {
+        Node *n = i;
+        i->n->p = i->p;
+        i->p->n = i->n;
+        i = i->n;
+        delete n;
+        d->size--;
+    }
+    return i;
+}
+template <typename T>
+QLinkedList<T> &QLinkedList<T>::operator+=(const QLinkedList<T> &l)
+{
+    detach();
+    int n = l.d->size;
+    d->size += n;
+    Node *original = l.e->n;
+    while (n--) {
+        try {
+            Node *copy = new Node(original->t);
+            original = original->n;
+            copy->n = e;
+            copy->p = e->p;
+            copy->p->n = copy;
+            e->p = copy;
+        } catch (...) {
+            while (n++<d->size)
+                removeLast();
+            throw;
+        }
+    }
+    return *this;
+}
+template <typename T>
+QLinkedList<T> QLinkedList<T>::operator+(const QLinkedList<T> &l) const
+{
+    QLinkedList<T> n = *this;
+    n += l;
+    return n;
+}
+template <class T> class QLinkedListIterator { typedef typename QLinkedList<T>::const_iterator const_iterator; QLinkedList<T> c; const_iterator i; public: inline QLinkedListIterator(const QLinkedList<T> &container) : c(container), i(c.constBegin()) {} inline QLinkedListIterator &operator=(const QLinkedList<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <class T> class QMutableLinkedListIterator { typedef typename QLinkedList<T>::iterator iterator; typedef typename QLinkedList<T>::const_iterator const_iterator; QLinkedList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableLinkedListIterator(QLinkedList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableLinkedListIterator() { c->setSharable(true); } inline QMutableLinkedListIterator &operator=(QLinkedList<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QMetaType {
+public:
+    enum Type {
+        Void = 0, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5,
+        Double = 6, QChar = 7, QVariantMap = 8, QVariantList = 9,
+        QString = 10, QStringList = 11, QByteArray = 12,
+        QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17,
+        QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22,
+        QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, QRegExp = 27,
+        QVariantHash = 28, QEasingCurve = 29, LastCoreType = QEasingCurve,
+        FirstGuiType = 63 ,
+        QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68,
+        QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73,
+        QCursor = 74, QSizePolicy = 75, QKeySequence = 76, QPen = 77,
+        QTextLength = 78, QTextFormat = 79, QMatrix = 80, QTransform = 81,
+        QMatrix4x4 = 82, QVector2D = 83, QVector3D = 84, QVector4D = 85,
+        QQuaternion = 86,
+        LastGuiType = QQuaternion,
+        FirstCoreExtType = 128 ,
+        VoidStar = 128, Long = 129, Short = 130, Char = 131, ULong = 132,
+        UShort = 133, UChar = 134, Float = 135, QObjectStar = 136, QWidgetStar = 137,
+        QVariant = 138,
+        LastCoreExtType = QVariant,
+        QReal = Double,
+        User = 256
+    };
+    typedef void (*Destructor)(void *);
+    typedef void *(*Constructor)(const void *);
+    typedef void (*SaveOperator)(QDataStream &, const void *);
+    typedef void (*LoadOperator)(QDataStream &, void *);
+    static void registerStreamOperators(const char *typeName, SaveOperator saveOp,
+                                        LoadOperator loadOp);
+    static void registerStreamOperators(int type, SaveOperator saveOp,
+                                        LoadOperator loadOp);
+    static int registerType(const char *typeName, Destructor destructor,
+                            Constructor constructor);
+    static int registerTypedef(const char *typeName, int aliasId);
+    static int type(const char *typeName);
+    static const char *typeName(int type);
+    static bool isRegistered(int type);
+    static void *construct(int type, const void *copy = 0);
+    static void destroy(int type, void *data);
+    static void unregisterType(const char *typeName);
+    static bool save(QDataStream &stream, int type, const void *data);
+    static bool load(QDataStream &stream, int type, void *data);
+};
+template <typename T>
+void qMetaTypeDeleteHelper(T *t)
+{
+    delete t;
+}
+template <typename T>
+void *qMetaTypeConstructHelper(const T *t)
+{
+    if (!t)
+        return new T();
+    return new T(*static_cast<const T*>(t));
+}
+template <typename T>
+void qMetaTypeSaveHelper(QDataStream &stream, const T *t)
+{
+    stream << *t;
+}
+template <typename T>
+void qMetaTypeLoadHelper(QDataStream &stream, T *t)
+{
+    stream >> *t;
+}
+template <typename T>
+struct QMetaTypeId
+{
+    enum { Defined = 0 };
+};
+template <typename T>
+struct QMetaTypeId2
+{
+    enum { Defined = QMetaTypeId<T>::Defined };
+    static inline int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); }
+};
+namespace QtPrivate {
+    template <typename T, bool Defined = QMetaTypeId2<T>::Defined>
+    struct QMetaTypeIdHelper {
+        static inline int qt_metatype_id()
+        { return QMetaTypeId2<T>::qt_metatype_id(); }
+    };
+    template <typename T> struct QMetaTypeIdHelper<T, false> {
+        static inline int qt_metatype_id()
+        { return -1; }
+    };
+}
+template <typename T>
+int qRegisterMetaType(const char *typeName
+    , T * dummy = 0
+)
+{
+    const int typedefOf = dummy ? -1 : QtPrivate::QMetaTypeIdHelper<T>::qt_metatype_id();
+    if (typedefOf != -1)
+        return QMetaType::registerTypedef(typeName, typedefOf);
+    typedef void*(*ConstructPtr)(const T*);
+    ConstructPtr cptr = qMetaTypeConstructHelper<T>;
+    typedef void(*DeletePtr)(T*);
+    DeletePtr dptr = qMetaTypeDeleteHelper<T>;
+    return QMetaType::registerType(typeName, reinterpret_cast<QMetaType::Destructor>(dptr),
+                                   reinterpret_cast<QMetaType::Constructor>(cptr));
+}
+template <typename T>
+void qRegisterMetaTypeStreamOperators(const char *typeName
+    , T * = 0
+)
+{
+    typedef void(*SavePtr)(QDataStream &, const T *);
+    typedef void(*LoadPtr)(QDataStream &, T *);
+    SavePtr sptr = qMetaTypeSaveHelper<T>;
+    LoadPtr lptr = qMetaTypeLoadHelper<T>;
+    qRegisterMetaType<T>(typeName);
+    QMetaType::registerStreamOperators(typeName, reinterpret_cast<QMetaType::SaveOperator>(sptr),
+                                       reinterpret_cast<QMetaType::LoadOperator>(lptr));
+}
+template <typename T>
+inline int qMetaTypeId(
+    T * = 0
+)
+{
+    return QMetaTypeId2<T>::qt_metatype_id();
+}
+template <typename T>
+inline int qRegisterMetaType(
+    T * dummy = 0
+)
+{
+    return qMetaTypeId(dummy);
+}
+template <typename T>
+inline int qRegisterMetaTypeStreamOperators()
+{
+    typedef void(*SavePtr)(QDataStream &, const T *);
+    typedef void(*LoadPtr)(QDataStream &, T *);
+    SavePtr sptr = qMetaTypeSaveHelper<T>;
+    LoadPtr lptr = qMetaTypeLoadHelper<T>;
+    register int id = qMetaTypeId<T>();
+    QMetaType::registerStreamOperators(id,
+                                       reinterpret_cast<QMetaType::SaveOperator>(sptr),
+                                       reinterpret_cast<QMetaType::LoadOperator>(lptr));
+    return id;
+}
+class QString;
+class QByteArray;
+class QChar;
+class QStringList;
+class QBitArray;
+class QDate;
+class QTime;
+class QDateTime;
+class QUrl;
+class QLocale;
+class QRect;
+class QRectF;
+class QSize;
+class QSizeF;
+class QLine;
+class QLineF;
+class QPoint;
+class QPointF;
+class QRegExp;
+class QEasingCurve;
+class QWidget;
+class QObject;
+class QFont;
+class QPixmap;
+class QBrush;
+class QColor;
+class QPalette;
+class QIcon;
+class QImage;
+class QPolygon;
+class QRegion;
+class QBitmap;
+class QCursor;
+class QSizePolicy;
+class QKeySequence;
+class QPen;
+class QTextLength;
+class QTextFormat;
+class QMatrix;
+class QTransform;
+class QMatrix4x4;
+class QVector2D;
+class QVector3D;
+class QVector4D;
+class QQuaternion;
+class QVariant;
+ template<> struct QMetaTypeId2<QString> { enum { Defined = 1, MetaType = QMetaType::QString }; static inline int qt_metatype_id() { return QMetaType::QString; } };
+ template<> struct QMetaTypeId2<int> { enum { Defined = 1, MetaType = QMetaType::Int }; static inline int qt_metatype_id() { return QMetaType::Int; } };
+ template<> struct QMetaTypeId2<uint> { enum { Defined = 1, MetaType = QMetaType::UInt }; static inline int qt_metatype_id() { return QMetaType::UInt; } };
+ template<> struct QMetaTypeId2<bool> { enum { Defined = 1, MetaType = QMetaType::Bool }; static inline int qt_metatype_id() { return QMetaType::Bool; } };
+ template<> struct QMetaTypeId2<double> { enum { Defined = 1, MetaType = QMetaType::Double }; static inline int qt_metatype_id() { return QMetaType::Double; } };
+ template<> struct QMetaTypeId2<QByteArray> { enum { Defined = 1, MetaType = QMetaType::QByteArray }; static inline int qt_metatype_id() { return QMetaType::QByteArray; } };
+ template<> struct QMetaTypeId2<QChar> { enum { Defined = 1, MetaType = QMetaType::QChar }; static inline int qt_metatype_id() { return QMetaType::QChar; } };
+ template<> struct QMetaTypeId2<long> { enum { Defined = 1, MetaType = QMetaType::Long }; static inline int qt_metatype_id() { return QMetaType::Long; } };
+ template<> struct QMetaTypeId2<short> { enum { Defined = 1, MetaType = QMetaType::Short }; static inline int qt_metatype_id() { return QMetaType::Short; } };
+ template<> struct QMetaTypeId2<char> { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } };
+ template<> struct QMetaTypeId2<signed char> { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } };
+ template<> struct QMetaTypeId2<ulong> { enum { Defined = 1, MetaType = QMetaType::ULong }; static inline int qt_metatype_id() { return QMetaType::ULong; } };
+ template<> struct QMetaTypeId2<ushort> { enum { Defined = 1, MetaType = QMetaType::UShort }; static inline int qt_metatype_id() { return QMetaType::UShort; } };
+ template<> struct QMetaTypeId2<uchar> { enum { Defined = 1, MetaType = QMetaType::UChar }; static inline int qt_metatype_id() { return QMetaType::UChar; } };
+ template<> struct QMetaTypeId2<float> { enum { Defined = 1, MetaType = QMetaType::Float }; static inline int qt_metatype_id() { return QMetaType::Float; } };
+ template<> struct QMetaTypeId2<QObject *> { enum { Defined = 1, MetaType = QMetaType::QObjectStar }; static inline int qt_metatype_id() { return QMetaType::QObjectStar; } };
+ template<> struct QMetaTypeId2<QWidget *> { enum { Defined = 1, MetaType = QMetaType::QWidgetStar }; static inline int qt_metatype_id() { return QMetaType::QWidgetStar; } };
+ template<> struct QMetaTypeId2<void *> { enum { Defined = 1, MetaType = QMetaType::VoidStar }; static inline int qt_metatype_id() { return QMetaType::VoidStar; } };
+ template<> struct QMetaTypeId2<qlonglong> { enum { Defined = 1, MetaType = QMetaType::LongLong }; static inline int qt_metatype_id() { return QMetaType::LongLong; } };
+ template<> struct QMetaTypeId2<qulonglong> { enum { Defined = 1, MetaType = QMetaType::ULongLong }; static inline int qt_metatype_id() { return QMetaType::ULongLong; } };
+ template<> struct QMetaTypeId2<QStringList> { enum { Defined = 1, MetaType = QMetaType::QStringList }; static inline int qt_metatype_id() { return QMetaType::QStringList; } };
+ template<> struct QMetaTypeId2<QBitArray> { enum { Defined = 1, MetaType = QMetaType::QBitArray }; static inline int qt_metatype_id() { return QMetaType::QBitArray; } };
+ template<> struct QMetaTypeId2<QDate> { enum { Defined = 1, MetaType = QMetaType::QDate }; static inline int qt_metatype_id() { return QMetaType::QDate; } };
+ template<> struct QMetaTypeId2<QTime> { enum { Defined = 1, MetaType = QMetaType::QTime }; static inline int qt_metatype_id() { return QMetaType::QTime; } };
+ template<> struct QMetaTypeId2<QDateTime> { enum { Defined = 1, MetaType = QMetaType::QDateTime }; static inline int qt_metatype_id() { return QMetaType::QDateTime; } };
+ template<> struct QMetaTypeId2<QUrl> { enum { Defined = 1, MetaType = QMetaType::QUrl }; static inline int qt_metatype_id() { return QMetaType::QUrl; } };
+ template<> struct QMetaTypeId2<QLocale> { enum { Defined = 1, MetaType = QMetaType::QLocale }; static inline int qt_metatype_id() { return QMetaType::QLocale; } };
+ template<> struct QMetaTypeId2<QRect> { enum { Defined = 1, MetaType = QMetaType::QRect }; static inline int qt_metatype_id() { return QMetaType::QRect; } };
+ template<> struct QMetaTypeId2<QRectF> { enum { Defined = 1, MetaType = QMetaType::QRectF }; static inline int qt_metatype_id() { return QMetaType::QRectF; } };
+ template<> struct QMetaTypeId2<QSize> { enum { Defined = 1, MetaType = QMetaType::QSize }; static inline int qt_metatype_id() { return QMetaType::QSize; } };
+ template<> struct QMetaTypeId2<QSizeF> { enum { Defined = 1, MetaType = QMetaType::QSizeF }; static inline int qt_metatype_id() { return QMetaType::QSizeF; } };
+ template<> struct QMetaTypeId2<QLine> { enum { Defined = 1, MetaType = QMetaType::QLine }; static inline int qt_metatype_id() { return QMetaType::QLine; } };
+ template<> struct QMetaTypeId2<QLineF> { enum { Defined = 1, MetaType = QMetaType::QLineF }; static inline int qt_metatype_id() { return QMetaType::QLineF; } };
+ template<> struct QMetaTypeId2<QPoint> { enum { Defined = 1, MetaType = QMetaType::QPoint }; static inline int qt_metatype_id() { return QMetaType::QPoint; } };
+ template<> struct QMetaTypeId2<QPointF> { enum { Defined = 1, MetaType = QMetaType::QPointF }; static inline int qt_metatype_id() { return QMetaType::QPointF; } };
+ template<> struct QMetaTypeId2<QRegExp> { enum { Defined = 1, MetaType = QMetaType::QRegExp }; static inline int qt_metatype_id() { return QMetaType::QRegExp; } };
+ template<> struct QMetaTypeId2<QEasingCurve> { enum { Defined = 1, MetaType = QMetaType::QEasingCurve }; static inline int qt_metatype_id() { return QMetaType::QEasingCurve; } };
+ template<> struct QMetaTypeId2<QFont> { enum { Defined = 1, MetaType = QMetaType::QFont }; static inline int qt_metatype_id() { return QMetaType::QFont; } };
+ template<> struct QMetaTypeId2<QPixmap> { enum { Defined = 1, MetaType = QMetaType::QPixmap }; static inline int qt_metatype_id() { return QMetaType::QPixmap; } };
+ template<> struct QMetaTypeId2<QBrush> { enum { Defined = 1, MetaType = QMetaType::QBrush }; static inline int qt_metatype_id() { return QMetaType::QBrush; } };
+ template<> struct QMetaTypeId2<QColor> { enum { Defined = 1, MetaType = QMetaType::QColor }; static inline int qt_metatype_id() { return QMetaType::QColor; } };
+ template<> struct QMetaTypeId2<QPalette> { enum { Defined = 1, MetaType = QMetaType::QPalette }; static inline int qt_metatype_id() { return QMetaType::QPalette; } };
+ template<> struct QMetaTypeId2<QIcon> { enum { Defined = 1, MetaType = QMetaType::QIcon }; static inline int qt_metatype_id() { return QMetaType::QIcon; } };
+ template<> struct QMetaTypeId2<QImage> { enum { Defined = 1, MetaType = QMetaType::QImage }; static inline int qt_metatype_id() { return QMetaType::QImage; } };
+ template<> struct QMetaTypeId2<QPolygon> { enum { Defined = 1, MetaType = QMetaType::QPolygon }; static inline int qt_metatype_id() { return QMetaType::QPolygon; } };
+ template<> struct QMetaTypeId2<QRegion> { enum { Defined = 1, MetaType = QMetaType::QRegion }; static inline int qt_metatype_id() { return QMetaType::QRegion; } };
+ template<> struct QMetaTypeId2<QBitmap> { enum { Defined = 1, MetaType = QMetaType::QBitmap }; static inline int qt_metatype_id() { return QMetaType::QBitmap; } };
+ template<> struct QMetaTypeId2<QCursor> { enum { Defined = 1, MetaType = QMetaType::QCursor }; static inline int qt_metatype_id() { return QMetaType::QCursor; } };
+ template<> struct QMetaTypeId2<QSizePolicy> { enum { Defined = 1, MetaType = QMetaType::QSizePolicy }; static inline int qt_metatype_id() { return QMetaType::QSizePolicy; } };
+ template<> struct QMetaTypeId2<QKeySequence> { enum { Defined = 1, MetaType = QMetaType::QKeySequence }; static inline int qt_metatype_id() { return QMetaType::QKeySequence; } };
+ template<> struct QMetaTypeId2<QPen> { enum { Defined = 1, MetaType = QMetaType::QPen }; static inline int qt_metatype_id() { return QMetaType::QPen; } };
+ template<> struct QMetaTypeId2<QTextLength> { enum { Defined = 1, MetaType = QMetaType::QTextLength }; static inline int qt_metatype_id() { return QMetaType::QTextLength; } };
+ template<> struct QMetaTypeId2<QTextFormat> { enum { Defined = 1, MetaType = QMetaType::QTextFormat }; static inline int qt_metatype_id() { return QMetaType::QTextFormat; } };
+ template<> struct QMetaTypeId2<QMatrix> { enum { Defined = 1, MetaType = QMetaType::QMatrix }; static inline int qt_metatype_id() { return QMetaType::QMatrix; } };
+ template<> struct QMetaTypeId2<QTransform> { enum { Defined = 1, MetaType = QMetaType::QTransform }; static inline int qt_metatype_id() { return QMetaType::QTransform; } };
+ template<> struct QMetaTypeId2<QMatrix4x4> { enum { Defined = 1, MetaType = QMetaType::QMatrix4x4 }; static inline int qt_metatype_id() { return QMetaType::QMatrix4x4; } };
+ template<> struct QMetaTypeId2<QVector2D> { enum { Defined = 1, MetaType = QMetaType::QVector2D }; static inline int qt_metatype_id() { return QMetaType::QVector2D; } };
+ template<> struct QMetaTypeId2<QVector3D> { enum { Defined = 1, MetaType = QMetaType::QVector3D }; static inline int qt_metatype_id() { return QMetaType::QVector3D; } };
+ template<> struct QMetaTypeId2<QVector4D> { enum { Defined = 1, MetaType = QMetaType::QVector4D }; static inline int qt_metatype_id() { return QMetaType::QVector4D; } };
+ template<> struct QMetaTypeId2<QQuaternion> { enum { Defined = 1, MetaType = QMetaType::QQuaternion }; static inline int qt_metatype_id() { return QMetaType::QQuaternion; } };
+ template<> struct QMetaTypeId2<QVariant> { enum { Defined = 1, MetaType = QMetaType::QVariant }; static inline int qt_metatype_id() { return QMetaType::QVariant; } };
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  enum _Rb_tree_color { _S_red = false, _S_black = true };
+  struct _Rb_tree_node_base
+  {
+    typedef _Rb_tree_node_base* _Base_ptr;
+    typedef const _Rb_tree_node_base* _Const_Base_ptr;
+    _Rb_tree_color _M_color;
+    _Base_ptr _M_parent;
+    _Base_ptr _M_left;
+    _Base_ptr _M_right;
+    static _Base_ptr
+    _S_minimum(_Base_ptr __x)
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+    static _Const_Base_ptr
+    _S_minimum(_Const_Base_ptr __x)
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+    static _Base_ptr
+    _S_maximum(_Base_ptr __x)
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+    static _Const_Base_ptr
+    _S_maximum(_Const_Base_ptr __x)
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+  };
+  template<typename _Val>
+    struct _Rb_tree_node : public _Rb_tree_node_base
+    {
+      typedef _Rb_tree_node<_Val>* _Link_type;
+      _Val _M_value_field;
+    };
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
+  template<typename _Tp>
+    struct _Rb_tree_iterator
+    {
+      typedef _Tp value_type;
+      typedef _Tp& reference;
+      typedef _Tp* pointer;
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+      typedef _Rb_tree_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
+      typedef _Rb_tree_node<_Tp>* _Link_type;
+      _Rb_tree_iterator()
+      : _M_node() { }
+      explicit
+      _Rb_tree_iterator(_Link_type __x)
+      : _M_node(__x) { }
+      reference
+      operator*() const
+      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
+      pointer
+      operator->() const
+      { return std::__addressof(static_cast<_Link_type>
+    (_M_node)->_M_value_field); }
+      _Self&
+      operator++()
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+      _Self&
+      operator--()
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+      _Base_ptr _M_node;
+  };
+  template<typename _Tp>
+    struct _Rb_tree_const_iterator
+    {
+      typedef _Tp value_type;
+      typedef const _Tp& reference;
+      typedef const _Tp* pointer;
+      typedef _Rb_tree_iterator<_Tp> iterator;
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+      typedef _Rb_tree_const_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
+      typedef const _Rb_tree_node<_Tp>* _Link_type;
+      _Rb_tree_const_iterator()
+      : _M_node() { }
+      explicit
+      _Rb_tree_const_iterator(_Link_type __x)
+      : _M_node(__x) { }
+      _Rb_tree_const_iterator(const iterator& __it)
+      : _M_node(__it._M_node) { }
+      iterator
+      _M_const_cast() const
+      { return iterator(static_cast<typename iterator::_Link_type>
+   (const_cast<typename iterator::_Base_ptr>(_M_node))); }
+      reference
+      operator*() const
+      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
+      pointer
+      operator->() const
+      { return std::__addressof(static_cast<_Link_type>
+    (_M_node)->_M_value_field); }
+      _Self&
+      operator++()
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+      _Self&
+      operator--()
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+      _Base_ptr _M_node;
+    };
+  template<typename _Val>
+    inline bool
+    operator==(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y)
+    { return __x._M_node == __y._M_node; }
+  template<typename _Val>
+    inline bool
+    operator!=(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y)
+    { return __x._M_node != __y._M_node; }
+  void
+  _Rb_tree_insert_and_rebalance(const bool __insert_left,
+                                _Rb_tree_node_base* __x,
+                                _Rb_tree_node_base* __p,
+                                _Rb_tree_node_base& __header) throw ();
+  _Rb_tree_node_base*
+  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
+          _Rb_tree_node_base& __header) throw ();
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc = allocator<_Val> >
+    class _Rb_tree
+    {
+      typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
+              _Node_allocator;
+    protected:
+      typedef _Rb_tree_node_base* _Base_ptr;
+      typedef const _Rb_tree_node_base* _Const_Base_ptr;
+    public:
+      typedef _Key key_type;
+      typedef _Val value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef _Rb_tree_node<_Val>* _Link_type;
+      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+      _Node_allocator&
+      _M_get_Node_allocator()
+      { return *static_cast<_Node_allocator*>(&this->_M_impl); }
+      const _Node_allocator&
+      _M_get_Node_allocator() const
+      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Node_allocator()); }
+    protected:
+      _Link_type
+      _M_get_node()
+      { return _M_impl._Node_allocator::allocate(1); }
+      void
+      _M_put_node(_Link_type __p)
+      { _M_impl._Node_allocator::deallocate(__p, 1); }
+      _Link_type
+      _M_create_node(const value_type& __x)
+      {
+ _Link_type __tmp = _M_get_node();
+ try
+   { get_allocator().construct
+       (std::__addressof(__tmp->_M_value_field), __x); }
+ catch(...)
+   {
+     _M_put_node(__tmp);
+     throw;
+   }
+ return __tmp;
+      }
+      void
+      _M_destroy_node(_Link_type __p)
+      {
+ get_allocator().destroy(std::__addressof(__p->_M_value_field));
+ _M_put_node(__p);
+      }
+      _Link_type
+      _M_clone_node(_Const_Link_type __x)
+      {
+ _Link_type __tmp = _M_create_node(__x->_M_value_field);
+ __tmp->_M_color = __x->_M_color;
+ __tmp->_M_left = 0;
+ __tmp->_M_right = 0;
+ return __tmp;
+      }
+    protected:
+      template<typename _Key_compare,
+        bool _Is_pod_comparator = __is_pod(_Key_compare)>
+        struct _Rb_tree_impl : public _Node_allocator
+        {
+   _Key_compare _M_key_compare;
+   _Rb_tree_node_base _M_header;
+   size_type _M_node_count;
+   _Rb_tree_impl()
+   : _Node_allocator(), _M_key_compare(), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
+   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+ private:
+   void
+   _M_initialize()
+   {
+     this->_M_header._M_color = _S_red;
+     this->_M_header._M_parent = 0;
+     this->_M_header._M_left = &this->_M_header;
+     this->_M_header._M_right = &this->_M_header;
+   }
+ };
+      _Rb_tree_impl<_Compare> _M_impl;
+    protected:
+      _Base_ptr&
+      _M_root()
+      { return this->_M_impl._M_header._M_parent; }
+      _Const_Base_ptr
+      _M_root() const
+      { return this->_M_impl._M_header._M_parent; }
+      _Base_ptr&
+      _M_leftmost()
+      { return this->_M_impl._M_header._M_left; }
+      _Const_Base_ptr
+      _M_leftmost() const
+      { return this->_M_impl._M_header._M_left; }
+      _Base_ptr&
+      _M_rightmost()
+      { return this->_M_impl._M_header._M_right; }
+      _Const_Base_ptr
+      _M_rightmost() const
+      { return this->_M_impl._M_header._M_right; }
+      _Link_type
+      _M_begin()
+      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
+      _Const_Link_type
+      _M_begin() const
+      {
+ return static_cast<_Const_Link_type>
+   (this->_M_impl._M_header._M_parent);
+      }
+      _Link_type
+      _M_end()
+      { return static_cast<_Link_type>(&this->_M_impl._M_header); }
+      _Const_Link_type
+      _M_end() const
+      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
+      static const_reference
+      _S_value(_Const_Link_type __x)
+      { return __x->_M_value_field; }
+      static const _Key&
+      _S_key(_Const_Link_type __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+      static _Link_type
+      _S_left(_Base_ptr __x)
+      { return static_cast<_Link_type>(__x->_M_left); }
+      static _Const_Link_type
+      _S_left(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x->_M_left); }
+      static _Link_type
+      _S_right(_Base_ptr __x)
+      { return static_cast<_Link_type>(__x->_M_right); }
+      static _Const_Link_type
+      _S_right(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x->_M_right); }
+      static const_reference
+      _S_value(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
+      static const _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+      static _Base_ptr
+      _S_minimum(_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+      static _Const_Base_ptr
+      _S_minimum(_Const_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+      static _Base_ptr
+      _S_maximum(_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+      static _Const_Base_ptr
+      _S_maximum(_Const_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+    public:
+      typedef _Rb_tree_iterator<value_type> iterator;
+      typedef _Rb_tree_const_iterator<value_type> const_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    private:
+      iterator
+      _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,
+   const value_type& __v);
+      iterator
+      _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
+      iterator
+      _M_insert_equal_lower(const value_type& __x);
+      _Link_type
+      _M_copy(_Const_Link_type __x, _Link_type __p);
+      void
+      _M_erase(_Link_type __x);
+      iterator
+      _M_lower_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+      const_iterator
+      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+      iterator
+      _M_upper_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+      const_iterator
+      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+    public:
+      _Rb_tree() { }
+      _Rb_tree(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_impl(__comp, __a) { }
+      _Rb_tree(const _Rb_tree& __x)
+      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
+      {
+ if (__x._M_root() != 0)
+   {
+     _M_root() = _M_copy(__x._M_begin(), _M_end());
+     _M_leftmost() = _S_minimum(_M_root());
+     _M_rightmost() = _S_maximum(_M_root());
+     _M_impl._M_node_count = __x._M_impl._M_node_count;
+   }
+      }
+      ~_Rb_tree()
+      { _M_erase(_M_begin()); }
+      _Rb_tree&
+      operator=(const _Rb_tree& __x);
+      _Compare
+      key_comp() const
+      { return _M_impl._M_key_compare; }
+      iterator
+      begin()
+      {
+ return iterator(static_cast<_Link_type>
+   (this->_M_impl._M_header._M_left));
+      }
+      const_iterator
+      begin() const
+      {
+ return const_iterator(static_cast<_Const_Link_type>
+         (this->_M_impl._M_header._M_left));
+      }
+      iterator
+      end()
+      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
+      const_iterator
+      end() const
+      {
+ return const_iterator(static_cast<_Const_Link_type>
+         (&this->_M_impl._M_header));
+      }
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+      bool
+      empty() const
+      { return _M_impl._M_node_count == 0; }
+      size_type
+      size() const
+      { return _M_impl._M_node_count; }
+      size_type
+      max_size() const
+      { return _M_get_Node_allocator().max_size(); }
+      void
+      swap(_Rb_tree& __t);
+      pair<iterator, bool>
+      _M_insert_unique(const value_type& __x);
+      iterator
+      _M_insert_equal(const value_type& __x);
+      iterator
+      _M_insert_unique_(const_iterator __position, const value_type& __x);
+      iterator
+      _M_insert_equal_(const_iterator __position, const value_type& __x);
+      template<typename _InputIterator>
+        void
+        _M_insert_unique(_InputIterator __first, _InputIterator __last);
+      template<typename _InputIterator>
+        void
+        _M_insert_equal(_InputIterator __first, _InputIterator __last);
+    private:
+      void
+      _M_erase_aux(const_iterator __position);
+      void
+      _M_erase_aux(const_iterator __first, const_iterator __last);
+    public:
+      void
+      erase(iterator __position)
+      { _M_erase_aux(__position); }
+      void
+      erase(const_iterator __position)
+      { _M_erase_aux(__position); }
+      size_type
+      erase(const key_type& __x);
+      void
+      erase(iterator __first, iterator __last)
+      { _M_erase_aux(__first, __last); }
+      void
+      erase(const_iterator __first, const_iterator __last)
+      { _M_erase_aux(__first, __last); }
+      void
+      erase(const key_type* __first, const key_type* __last);
+      void
+      clear()
+      {
+        _M_erase(_M_begin());
+        _M_leftmost() = _M_end();
+        _M_root() = 0;
+        _M_rightmost() = _M_end();
+        _M_impl._M_node_count = 0;
+      }
+      iterator
+      find(const key_type& __k);
+      const_iterator
+      find(const key_type& __k) const;
+      size_type
+      count(const key_type& __k) const;
+      iterator
+      lower_bound(const key_type& __k)
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+      const_iterator
+      lower_bound(const key_type& __k) const
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+      iterator
+      upper_bound(const key_type& __k)
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+      const_iterator
+      upper_bound(const key_type& __k) const
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+      pair<iterator, iterator>
+      equal_range(const key_type& __k);
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+      bool
+      __rb_verify() const;
+    };
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return __x.size() == __y.size()
+      && std::equal(__x.begin(), __x.end(), __y.begin());
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end());
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
+    {
+      if (this != &__x)
+ {
+   clear();
+   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+   if (__x._M_root() != 0)
+     {
+       _M_root() = _M_copy(__x._M_begin(), _M_end());
+       _M_leftmost() = _S_minimum(_M_root());
+       _M_rightmost() = _S_maximum(_M_root());
+       _M_impl._M_node_count = __x._M_impl._M_node_count;
+     }
+ }
+      return *this;
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+       || _M_impl._M_key_compare(_KeyOfValue()(__v),
+            _S_key(__p)));
+      _Link_type __z = _M_create_node((__v));
+      _Rb_tree_insert_and_rebalance(__insert_left, __z,
+        const_cast<_Base_ptr>(__p),
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+       || !_M_impl._M_key_compare(_S_key(__p),
+             _KeyOfValue()(__v)));
+      _Link_type __z = _M_create_node((__v));
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_lower(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_lower(__x, __y, (__v));
+    }
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
+    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
+    _M_copy(_Const_Link_type __x, _Link_type __p)
+    {
+      _Link_type __top = _M_clone_node(__x);
+      __top->_M_parent = __p;
+      try
+ {
+   if (__x->_M_right)
+     __top->_M_right = _M_copy(_S_right(__x), __top);
+   __p = __top;
+   __x = _S_left(__x);
+   while (__x != 0)
+     {
+       _Link_type __y = _M_clone_node(__x);
+       __p->_M_left = __y;
+       __y->_M_parent = __p;
+       if (__x->_M_right)
+  __y->_M_right = _M_copy(_S_right(__x), __y);
+       __p = __y;
+       __x = _S_left(__x);
+     }
+ }
+      catch(...)
+ {
+   _M_erase(__top);
+   throw;
+ }
+      return __top;
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase(_Link_type __x)
+    {
+      while (__x != 0)
+ {
+   _M_erase(_S_right(__x));
+   _Link_type __y = _S_left(__x);
+   _M_destroy_node(__x);
+   __x = __y;
+ }
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<iterator,
+            iterator>(_M_lower_bound(__x, __y, __k),
+        _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<iterator, iterator>(iterator(__y),
+          iterator(__y));
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k) const
+    {
+      _Const_Link_type __x = _M_begin();
+      _Const_Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Const_Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<const_iterator,
+            const_iterator>(_M_lower_bound(__x, __y, __k),
+       _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<const_iterator, const_iterator>(const_iterator(__y),
+        const_iterator(__y));
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
+    {
+      if (_M_root() == 0)
+ {
+   if (__t._M_root() != 0)
+     {
+       _M_root() = __t._M_root();
+       _M_leftmost() = __t._M_leftmost();
+       _M_rightmost() = __t._M_rightmost();
+       _M_root()->_M_parent = _M_end();
+       __t._M_root() = 0;
+       __t._M_leftmost() = __t._M_end();
+       __t._M_rightmost() = __t._M_end();
+     }
+ }
+      else if (__t._M_root() == 0)
+ {
+   __t._M_root() = _M_root();
+   __t._M_leftmost() = _M_leftmost();
+   __t._M_rightmost() = _M_rightmost();
+   __t._M_root()->_M_parent = __t._M_end();
+   _M_root() = 0;
+   _M_leftmost() = _M_end();
+   _M_rightmost() = _M_end();
+ }
+      else
+ {
+   std::swap(_M_root(),__t._M_root());
+   std::swap(_M_leftmost(),__t._M_leftmost());
+   std::swap(_M_rightmost(),__t._M_rightmost());
+   _M_root()->_M_parent = _M_end();
+   __t._M_root()->_M_parent = __t._M_end();
+ }
+      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
+      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
+      std::__alloc_swap<_Node_allocator>::
+ _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator, bool>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_unique(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      bool __comp = true;
+      while (__x != 0)
+ {
+   __y = __x;
+   __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
+   __x = __comp ? _S_left(__x) : _S_right(__x);
+ }
+      iterator __j = iterator(__y);
+      if (__comp)
+ {
+   if (__j == begin())
+     return pair<iterator, bool>
+       (_M_insert_(__x, __y, (__v)), true);
+   else
+     --__j;
+ }
+      if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
+ return pair<iterator, bool>
+   (_M_insert_(__x, __y, (__v)), true);
+      return pair<iterator, bool>(__j, false);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_(__x, __y, (__v));
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_unique_(const_iterator __position, const _Val& __v)
+    {
+      if (__position._M_node == _M_end())
+ {
+   if (size() > 0
+       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
+     _KeyOfValue()(__v)))
+     return _M_insert_(0, _M_rightmost(), (__v));
+   else
+     return _M_insert_unique((__v)).first;
+ }
+      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
+          _S_key(__position._M_node)))
+ {
+   const_iterator __before = __position;
+   if (__position._M_node == _M_leftmost())
+     return _M_insert_(_M_leftmost(), _M_leftmost(),
+         (__v));
+   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
+       _KeyOfValue()(__v)))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _M_insert_(0, __before._M_node,
+      (__v));
+       else
+  return _M_insert_(__position._M_node,
+      __position._M_node,
+      (__v));
+     }
+   else
+     return _M_insert_unique((__v)).first;
+ }
+      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
+          _KeyOfValue()(__v)))
+ {
+   const_iterator __after = __position;
+   if (__position._M_node == _M_rightmost())
+     return _M_insert_(0, _M_rightmost(),
+         (__v));
+   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
+       _S_key((++__after)._M_node)))
+     {
+       if (_S_right(__position._M_node) == 0)
+  return _M_insert_(0, __position._M_node,
+      (__v));
+       else
+  return _M_insert_(__after._M_node, __after._M_node,
+      (__v));
+     }
+   else
+     return _M_insert_unique((__v)).first;
+ }
+      else
+ return __position._M_const_cast();
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_(const_iterator __position, const _Val& __v)
+    {
+      if (__position._M_node == _M_end())
+ {
+   if (size() > 0
+       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
+      _S_key(_M_rightmost())))
+     return _M_insert_(0, _M_rightmost(),
+         (__v));
+   else
+     return _M_insert_equal((__v));
+ }
+      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
+           _KeyOfValue()(__v)))
+ {
+   const_iterator __before = __position;
+   if (__position._M_node == _M_leftmost())
+     return _M_insert_(_M_leftmost(), _M_leftmost(),
+         (__v));
+   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
+        _S_key((--__before)._M_node)))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _M_insert_(0, __before._M_node,
+      (__v));
+       else
+  return _M_insert_(__position._M_node,
+      __position._M_node,
+      (__v));
+     }
+   else
+     return _M_insert_equal((__v));
+ }
+      else
+ {
+   const_iterator __after = __position;
+   if (__position._M_node == _M_rightmost())
+     return _M_insert_(0, _M_rightmost(),
+         (__v));
+   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
+        _KeyOfValue()(__v)))
+     {
+       if (_S_right(__position._M_node) == 0)
+  return _M_insert_(0, __position._M_node,
+      (__v));
+       else
+  return _M_insert_(__after._M_node, __after._M_node,
+      (__v));
+     }
+   else
+     return _M_insert_equal_lower((__v));
+ }
+    }
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_unique(_II __first, _II __last)
+      {
+ for (; __first != __last; ++__first)
+   _M_insert_unique_(end(), *__first);
+      }
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_equal(_II __first, _II __last)
+      {
+ for (; __first != __last; ++__first)
+   _M_insert_equal_(end(), *__first);
+      }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __position)
+    {
+      _Link_type __y =
+ static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+    (const_cast<_Base_ptr>(__position._M_node),
+     this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __first, const_iterator __last)
+    {
+      if (__first == begin() && __last == end())
+ clear();
+      else
+ while (__first != __last)
+   erase(__first++);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key& __x)
+    {
+      pair<iterator, iterator> __p = equal_range(__x);
+      const size_type __old_size = size();
+      erase(__p.first, __p.second);
+      return __old_size - size();
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key* __first, const _Key* __last)
+    {
+      while (__first != __last)
+ erase(*__first++);
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k)
+    {
+      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k) const
+    {
+      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    count(const _Key& __k) const
+    {
+      pair<const_iterator, const_iterator> __p = equal_range(__k);
+      const size_type __n = std::distance(__p.first, __p.second);
+      return __n;
+    }
+  __attribute__ ((__pure__)) unsigned int
+  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
+                       const _Rb_tree_node_base* __root) throw ();
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    bool
+    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
+    {
+      if (_M_impl._M_node_count == 0 || begin() == end())
+ return _M_impl._M_node_count == 0 && begin() == end()
+        && this->_M_impl._M_header._M_left == _M_end()
+        && this->_M_impl._M_header._M_right == _M_end();
+      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
+      for (const_iterator __it = begin(); __it != end(); ++__it)
+ {
+   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
+   _Const_Link_type __L = _S_left(__x);
+   _Const_Link_type __R = _S_right(__x);
+   if (__x->_M_color == _S_red)
+     if ((__L && __L->_M_color == _S_red)
+  || (__R && __R->_M_color == _S_red))
+       return false;
+   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
+     return false;
+   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
+     return false;
+   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
+     return false;
+ }
+      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+ return false;
+      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+ return false;
+      return true;
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+    private:
+      typedef typename _Alloc::value_type _Alloc_value_type;
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class map<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+ value_compare(_Compare __c)
+ : comp(__c) { }
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+    private:
+      typedef typename _Alloc::template rebind<value_type>::other
+        _Pair_alloc_type;
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+      _Rep_type _M_t;
+    public:
+      typedef typename _Pair_alloc_type::pointer pointer;
+      typedef typename _Pair_alloc_type::const_pointer const_pointer;
+      typedef typename _Pair_alloc_type::reference reference;
+      typedef typename _Pair_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      map()
+      : _M_t() { }
+      explicit
+      map(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+      map(const map& __x)
+      : _M_t(__x._M_t) { }
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_unique(__first, __last); }
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+     const _Compare& __comp,
+     const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a)
+        { _M_t._M_insert_unique(__first, __last); }
+      map&
+      operator=(const map& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+      iterator
+      begin()
+      { return _M_t.begin(); }
+      const_iterator
+      begin() const
+      { return _M_t.begin(); }
+      iterator
+      end()
+      { return _M_t.end(); }
+      const_iterator
+      end() const
+      { return _M_t.end(); }
+      reverse_iterator
+      rbegin()
+      { return _M_t.rbegin(); }
+      const_reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+      reverse_iterator
+      rend()
+      { return _M_t.rend(); }
+      const_reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+      bool
+      empty() const
+      { return _M_t.empty(); }
+      size_type
+      size() const
+      { return _M_t.size(); }
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+ iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+          __i = insert(__i, value_type(__k, mapped_type()));
+ return (*__i).second;
+      }
+      mapped_type&
+      at(const key_type& __k)
+      {
+ iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+ const_iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+      iterator
+      insert(iterator __position, const value_type& __x)
+      { return _M_t._M_insert_unique_(__position, __x); }
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_unique(__first, __last); }
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+      void
+      swap(map& __x)
+      { _M_t.swap(__x._M_t); }
+      void
+      clear()
+      { _M_t.clear(); }
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const map<_K1, _T1, _C1, _A1>&,
+     const map<_K1, _T1, _C1, _A1>&);
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const map<_K1, _T1, _C1, _A1>&,
+    const map<_K1, _T1, _C1, _A1>&);
+    };
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+  map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <typename _Key, typename _Tp,
+     typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+    private:
+      typedef typename _Alloc::value_type _Alloc_value_type;
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class multimap<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+ value_compare(_Compare __c)
+ : comp(__c) { }
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+    private:
+      typedef typename _Alloc::template rebind<value_type>::other
+        _Pair_alloc_type;
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+      _Rep_type _M_t;
+    public:
+      typedef typename _Pair_alloc_type::pointer pointer;
+      typedef typename _Pair_alloc_type::const_pointer const_pointer;
+      typedef typename _Pair_alloc_type::reference reference;
+      typedef typename _Pair_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      multimap()
+      : _M_t() { }
+      explicit
+      multimap(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+      multimap(const multimap& __x)
+      : _M_t(__x._M_t) { }
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+   const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+        : _M_t(__comp, __a)
+        { _M_t._M_insert_equal(__first, __last); }
+      multimap&
+      operator=(const multimap& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+      iterator
+      begin()
+      { return _M_t.begin(); }
+      const_iterator
+      begin() const
+      { return _M_t.begin(); }
+      iterator
+      end()
+      { return _M_t.end(); }
+      const_iterator
+      end() const
+      { return _M_t.end(); }
+      reverse_iterator
+      rbegin()
+      { return _M_t.rbegin(); }
+      const_reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+      reverse_iterator
+      rend()
+      { return _M_t.rend(); }
+      const_reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+      bool
+      empty() const
+      { return _M_t.empty(); }
+      size_type
+      size() const
+      { return _M_t.size(); }
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+      iterator
+      insert(iterator __position, const value_type& __x)
+      { return _M_t._M_insert_equal_(__position, __x); }
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+      void
+      swap(multimap& __x)
+      { _M_t.swap(__x._M_t); }
+      void
+      clear()
+      { _M_t.clear(); }
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multimap<_K1, _T1, _C1, _A1>&,
+     const multimap<_K1, _T1, _C1, _A1>&);
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const multimap<_K1, _T1, _C1, _A1>&,
+    const multimap<_K1, _T1, _C1, _A1>&);
+  };
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QMapData
+{
+    struct Node {
+        Node *backward;
+        Node *forward[1];
+    };
+    enum { LastLevel = 11, Sparseness = 3 };
+    QMapData *backward;
+    QMapData *forward[QMapData::LastLevel + 1];
+    QBasicAtomicInt ref;
+    int topLevel;
+    int size;
+    uint randomBits;
+    uint insertInOrder : 1;
+    uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 29;
+    static QMapData *createData();
+    static QMapData *createData(int alignment);
+    void continueFreeData(int offset);
+    Node *node_create(Node *update[], int offset);
+    Node *node_create(Node *update[], int offset, int alignment);
+    void node_delete(Node *update[], int offset, Node *node);
+    static QMapData shared_null;
+};
+template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2)
+{
+    return key1 < key2;
+}
+template <class Ptr> inline bool qMapLessThanKey(Ptr *key1, Ptr *key2)
+{
+    qt_noop();
+    return quintptr(key1) < quintptr(key2);
+}
+template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
+{
+    qt_noop();
+    return quintptr(key1) < quintptr(key2);
+}
+template <class Key, class T>
+struct QMapNode {
+    Key key;
+    T value;
+private:
+    QMapData::Node *backward;
+    QMapData::Node *forward[1];
+};
+template <class Key, class T>
+struct QMapPayloadNode
+{
+    Key key;
+    T value;
+private:
+    QMapData::Node *backward;
+};
+template <class Key, class T>
+class QMap
+{
+    typedef QMapNode<Key, T> Node;
+    typedef QMapPayloadNode<Key, T> PayloadNode;
+    union {
+        QMapData *d;
+        QMapData::Node *e;
+    };
+    static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); }
+    static inline int alignment() {
+        return int(qMax(sizeof(void*), __alignof__(Node)));
+    }
+    static inline Node *concrete(QMapData::Node *node) {
+        return reinterpret_cast<Node *>(reinterpret_cast<char *>(node) - payload());
+    }
+public:
+    inline QMap() : d(&QMapData::shared_null) { d->ref.ref(); }
+    inline QMap(const QMap<Key, T> &other) : d(other.d)
+    { d->ref.ref(); if (!d->sharable) detach(); }
+    inline ~QMap() { if (!d) return; if (!d->ref.deref()) freeData(d); }
+    QMap<Key, T> &operator=(const QMap<Key, T> &other);
+    inline void swap(QMap<Key, T> &other) { qSwap(d, other.d); }
+    explicit QMap(const typename std::map<Key, T> &other);
+    std::map<Key, T> toStdMap() const;
+    bool operator==(const QMap<Key, T> &other) const;
+    inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); }
+    inline int size() const { return d->size; }
+    inline bool isEmpty() const { return d->size == 0; }
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline bool isSharedWith(const QMap<Key, T> &other) const { return d == other.d; }
+    inline void setInsertInOrder(bool ordered) { d->insertInOrder = ordered; }
+    void clear();
+    int remove(const Key &key);
+    T take(const Key &key);
+    bool contains(const Key &key) const;
+    const Key key(const T &value) const;
+    const Key key(const T &value, const Key &defaultKey) const;
+    const T value(const Key &key) const;
+    const T value(const Key &key, const T &defaultValue) const;
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+    QList<Key> uniqueKeys() const;
+    QList<Key> keys() const;
+    QList<Key> keys(const T &value) const;
+    QList<T> values() const;
+    QList<T> values(const Key &key) const;
+    int count(const Key &key) const;
+    class const_iterator;
+    class iterator
+    {
+        friend class const_iterator;
+        QMapData::Node *i;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+        inline operator QMapData::Node *() const { return i; }
+        inline iterator() : i(0) { }
+        inline iterator(QMapData::Node *node) : i(node) { }
+        inline const Key &key() const { return concrete(i)->key; }
+        inline T &value() const { return concrete(i)->value; }
+        inline T &operator*() const { return concrete(i)->value; }
+        inline T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline iterator &operator++() {
+            i = i->forward[0];
+            return *this;
+        }
+        inline iterator operator++(int) {
+            iterator r = *this;
+            i = i->forward[0];
+            return r;
+        }
+        inline iterator &operator--() {
+            i = i->backward;
+            return *this;
+        }
+        inline iterator operator--(int) {
+            iterator r = *this;
+            i = i->backward;
+            return r;
+        }
+        inline iterator operator+(int j) const
+        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { return *this = *this + j; }
+        inline iterator &operator-=(int j) { return *this = *this - j; }
+    public:
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+    private:
+        inline operator bool() const { return false; }
+    };
+    friend class iterator;
+    class const_iterator
+    {
+        friend class iterator;
+        QMapData::Node *i;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline operator QMapData::Node *() const { return i; }
+        inline const_iterator() : i(0) { }
+        inline const_iterator(QMapData::Node *node) : i(node) { }
+        inline const_iterator(const iterator &o)
+        { i = o.i; }
+        inline const Key &key() const { return concrete(i)->key; }
+        inline const T &value() const { return concrete(i)->value; }
+        inline const T &operator*() const { return concrete(i)->value; }
+        inline const T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() {
+            i = i->forward[0];
+            return *this;
+        }
+        inline const_iterator operator++(int) {
+            const_iterator r = *this;
+            i = i->forward[0];
+            return r;
+        }
+        inline const_iterator &operator--() {
+            i = i->backward;
+            return *this;
+        }
+        inline const_iterator operator--(int) {
+            const_iterator r = *this;
+            i = i->backward;
+            return r;
+        }
+        inline const_iterator operator+(int j) const
+        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { return *this = *this + j; }
+        inline const_iterator &operator-=(int j) { return *this = *this - j; }
+    private:
+        inline operator bool() const { return false; }
+    };
+    friend class const_iterator;
+    inline iterator begin() { detach(); return iterator(e->forward[0]); }
+    inline const_iterator begin() const { return const_iterator(e->forward[0]); }
+    inline const_iterator constBegin() const { return const_iterator(e->forward[0]); }
+    inline iterator end() {
+        detach();
+        return iterator(e);
+    }
+    inline const_iterator end() const { return const_iterator(e); }
+    inline const_iterator constEnd() const { return const_iterator(e); }
+    iterator erase(iterator it);
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator lowerBound(const Key &key);
+    const_iterator lowerBound(const Key &key) const;
+    iterator upperBound(const Key &key);
+    const_iterator upperBound(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+    iterator insertMulti(const Key &key, const T &value);
+    QMap<Key, T> &unite(const QMap<Key, T> &other);
+    typedef Key key_type;
+    typedef T mapped_type;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+    inline bool empty() const { return isEmpty(); }
+private:
+    void detach_helper();
+    void freeData(QMapData *d);
+    QMapData::Node *findNode(const Key &key) const;
+    QMapData::Node *mutableFindNode(QMapData::Node *update[], const Key &key) const;
+    QMapData::Node *node_create(QMapData *d, QMapData::Node *update[], const Key &key,
+                                const T &value);
+};
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
+{
+    if (d != other.d) {
+        QMapData* o = other.d;
+        o->ref.ref();
+        if (!d->ref.deref())
+            freeData(d);
+        d = o;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+template <class Key, class T>
+inline void QMap<Key, T>::clear()
+{
+    *this = QMap<Key, T>();
+}
+template <class Key, class T>
+inline typename QMapData::Node *
+QMap<Key, T>::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue)
+{
+    QMapData::Node *abstractNode = adt->node_create(aupdate, payload(), alignment());
+    try {
+        Node *concreteNode = concrete(abstractNode);
+        new (&concreteNode->key) Key(akey);
+        try {
+            new (&concreteNode->value) T(avalue);
+        } catch (...) {
+            concreteNode->key.~Key();
+            throw;
+        }
+    } catch (...) {
+        adt->node_delete(aupdate, payload(), abstractNode);
+        throw;
+    }
+    return abstractNode;
+}
+template <class Key, class T>
+inline QMapData::Node *QMap<Key, T>::findNode(const Key &akey) const
+{
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+    }
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        return next;
+    } else {
+        return e;
+    }
+}
+template <class Key, class T>
+inline const T QMap<Key, T>::value(const Key &akey) const
+{
+    QMapData::Node *node;
+    if (d->size == 0 || (node = findNode(akey)) == e) {
+        return T();
+    } else {
+        return concrete(node)->value;
+    }
+}
+template <class Key, class T>
+inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const
+{
+    QMapData::Node *node;
+    if (d->size == 0 || (node = findNode(akey)) == e) {
+        return adefaultValue;
+    } else {
+        return concrete(node)->value;
+    }
+}
+template <class Key, class T>
+inline const T QMap<Key, T>::operator[](const Key &akey) const
+{
+    return value(akey);
+}
+template <class Key, class T>
+inline T &QMap<Key, T>::operator[](const Key &akey)
+{
+    detach();
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *node = mutableFindNode(update, akey);
+    if (node == e)
+        node = node_create(d, update, akey, T());
+    return concrete(node)->value;
+}
+template <class Key, class T>
+inline int QMap<Key, T>::count(const Key &akey) const
+{
+    int cnt = 0;
+    QMapData::Node *node = findNode(akey);
+    if (node != e) {
+        do {
+            ++cnt;
+            node = node->forward[0];
+        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
+    }
+    return cnt;
+}
+template <class Key, class T>
+inline bool QMap<Key, T>::contains(const Key &akey) const
+{
+    return findNode(akey) != e;
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey,
+                                                                       const T &avalue)
+{
+    detach();
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *node = mutableFindNode(update, akey);
+    if (node == e) {
+        node = node_create(d, update, akey, avalue);
+    } else {
+        concrete(node)->value = avalue;
+    }
+    return iterator(node);
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const Key &akey,
+                                                                            const T &avalue)
+{
+    detach();
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    return iterator(node_create(d, update, akey, avalue));
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const
+{
+    return const_iterator(findNode(akey));
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const
+{
+    return const_iterator(findNode(akey));
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey)
+{
+    detach();
+    return iterator(findNode(akey));
+}
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::unite(const QMap<Key, T> &other)
+{
+    QMap<Key, T> copy(other);
+    const_iterator it = copy.constEnd();
+    const const_iterator b = copy.constBegin();
+    while (it != b) {
+        --it;
+        insertMulti(it.key(), it.value());
+    }
+    return *this;
+}
+template <class Key, class T>
+ void QMap<Key, T>::freeData(QMapData *x)
+{
+    if (QTypeInfo<Key>::isComplex || QTypeInfo<T>::isComplex) {
+        QMapData *cur = x;
+        QMapData *next = cur->forward[0];
+        while (next != x) {
+            cur = next;
+            next = cur->forward[0];
+            Node *concreteNode = concrete(reinterpret_cast<QMapData::Node *>(cur));
+            concreteNode->key.~Key();
+            concreteNode->value.~T();
+        }
+    }
+    x->continueFreeData(payload());
+}
+template <class Key, class T>
+ int QMap<Key, T>::remove(const Key &akey)
+{
+    detach();
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    int oldSize = d->size;
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        update[i] = cur;
+    }
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        bool deleteNext = true;
+        do {
+            cur = next;
+            next = cur->forward[0];
+            deleteNext = (next != e && !qMapLessThanKey<Key>(concrete(cur)->key, concrete(next)->key));
+            concrete(cur)->key.~Key();
+            concrete(cur)->value.~T();
+            d->node_delete(update, payload(), cur);
+        } while (deleteNext);
+    }
+    return oldSize - d->size;
+}
+template <class Key, class T>
+ T QMap<Key, T>::take(const Key &akey)
+{
+    detach();
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        update[i] = cur;
+    }
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        T t = concrete(next)->value;
+        concrete(next)->key.~Key();
+        concrete(next)->value.~T();
+        d->node_delete(update, payload(), next);
+        return t;
+    }
+    return T();
+}
+template <class Key, class T>
+ typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it)
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    if (it == iterator(e))
+        return it;
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, it.key()))
+            cur = next;
+        update[i] = cur;
+    }
+    while (next != e) {
+        cur = next;
+        next = cur->forward[0];
+        if (cur == it) {
+            concrete(cur)->key.~Key();
+            concrete(cur)->value.~T();
+            d->node_delete(update, payload(), cur);
+            return iterator(next);
+        }
+        for (int i = 0; i <= d->topLevel; ++i) {
+            if (update[i]->forward[i] != cur)
+                break;
+            update[i] = cur;
+        }
+    }
+    return end();
+}
+template <class Key, class T>
+ void QMap<Key, T>::detach_helper()
+{
+    union { QMapData *d; QMapData::Node *e; } x;
+    x.d = QMapData::createData(alignment());
+    if (d->size) {
+        x.d->insertInOrder = true;
+        QMapData::Node *update[QMapData::LastLevel + 1];
+        QMapData::Node *cur = e->forward[0];
+        update[0] = x.e;
+        while (cur != e) {
+            try {
+                Node *concreteNode = concrete(cur);
+                node_create(x.d, update, concreteNode->key, concreteNode->value);
+            } catch (...) {
+                freeData(x.d);
+                throw;
+            }
+            cur = cur->forward[0];
+        }
+        x.d->insertInOrder = false;
+    }
+    if (!d->ref.deref())
+        freeData(d);
+    d = x.d;
+}
+template <class Key, class T>
+ QMapData::Node *QMap<Key, T>::mutableFindNode(QMapData::Node *aupdate[],
+                                                                   const Key &akey) const
+{
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        aupdate[i] = cur;
+    }
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        return next;
+    } else {
+        return e;
+    }
+}
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::uniqueKeys() const
+{
+    QList<Key> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    if (i != end()) {
+        for (;;) {
+            const Key &aKey = i.key();
+            res.append(aKey);
+            do {
+                if (++i == end())
+                    goto break_out_of_outer_loop;
+            } while (!(aKey < i.key()));
+        }
+    }
+break_out_of_outer_loop:
+    return res;
+}
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::keys() const
+{
+    QList<Key> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::keys(const T &avalue) const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ const Key QMap<Key, T>::key(const T &avalue) const
+{
+    return key(avalue, Key());
+}
+template <class Key, class T>
+ const Key QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const
+{
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            return i.key();
+        ++i;
+    }
+    return defaultKey;
+}
+template <class Key, class T>
+ QList<T> QMap<Key, T>::values() const
+{
+    QList<T> res;
+    res.reserve(size());
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.value());
+        ++i;
+    }
+    return res;
+}
+template <class Key, class T>
+ QList<T> QMap<Key, T>::values(const Key &akey) const
+{
+    QList<T> res;
+    QMapData::Node *node = findNode(akey);
+    if (node != e) {
+        do {
+            res.append(concrete(node)->value);
+            node = node->forward[0];
+        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
+    }
+    return res;
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator
+QMap<Key, T>::lowerBound(const Key &akey) const
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    return const_iterator(update[0]->forward[0]);
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey)
+{
+    detach();
+    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->lowerBound(akey));
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator
+QMap<Key, T>::upperBound(const Key &akey) const
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    QMapData::Node *node = update[0]->forward[0];
+    while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key))
+        node = node->forward[0];
+    return const_iterator(node);
+}
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey)
+{
+    detach();
+    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->upperBound(akey));
+}
+template <class Key, class T>
+ bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+    const_iterator it1 = begin();
+    const_iterator it2 = other.begin();
+    while (it1 != end()) {
+        if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
+            return false;
+        ++it2;
+        ++it1;
+    }
+    return true;
+}
+template <class Key, class T>
+ QMap<Key, T>::QMap(const std::map<Key, T> &other)
+{
+    d = QMapData::createData(alignment());
+    d->insertInOrder = true;
+    typename std::map<Key,T>::const_iterator it = other.end();
+    while (it != other.begin()) {
+        --it;
+        insert((*it).first, (*it).second);
+    }
+    d->insertInOrder = false;
+}
+template <class Key, class T>
+ std::map<Key, T> QMap<Key, T>::toStdMap() const
+{
+    std::map<Key, T> map;
+    const_iterator it = end();
+    while (it != begin()) {
+        --it;
+        map.insert(std::pair<Key, T>(it.key(), it.value()));
+    }
+    return map;
+}
+template <class Key, class T>
+class QMultiMap : public QMap<Key, T>
+{
+public:
+    QMultiMap() {}
+    QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}
+    inline void swap(QMultiMap<Key, T> &other) { QMap<Key, T>::swap(other); }
+    inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value)
+    { return QMap<Key, T>::insert(key, value); }
+    inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value)
+    { return QMap<Key, T>::insertMulti(key, value); }
+    inline QMultiMap &operator+=(const QMultiMap &other)
+    { this->unite(other); return *this; }
+    inline QMultiMap operator+(const QMultiMap &other) const
+    { QMultiMap result = *this; result += other; return result; }
+    using QMap<Key, T>::contains;
+    using QMap<Key, T>::remove;
+    using QMap<Key, T>::count;
+    using QMap<Key, T>::find;
+    using QMap<Key, T>::constFind;
+    bool contains(const Key &key, const T &value) const;
+    int remove(const Key &key, const T &value);
+    int count(const Key &key, const T &value) const;
+    typename QMap<Key, T>::iterator find(const Key &key, const T &value) {
+        typename QMap<Key, T>::iterator i(find(key));
+        typename QMap<Key, T>::iterator end(this->end());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const {
+        typename QMap<Key, T>::const_iterator i(constFind(key));
+        typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<Key, T>::const_iterator constFind(const Key &key, const T &value) const
+        { return find(key, value); }
+private:
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+};
+template <class Key, class T>
+inline bool QMultiMap<Key, T>::contains(const Key &key, const T &value) const
+{
+    return constFind(key, value) != QMap<Key, T>::constEnd();
+}
+template <class Key, class T>
+inline int QMultiMap<Key, T>::remove(const Key &key, const T &value)
+{
+    int n = 0;
+    typename QMap<Key, T>::iterator i(find(key));
+    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value) {
+            i = this->erase(i);
+            ++n;
+        } else {
+            ++i;
+        }
+    }
+    return n;
+}
+template <class Key, class T>
+inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const
+{
+    int n = 0;
+    typename QMap<Key, T>::const_iterator i(constFind(key));
+    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value)
+            ++n;
+        ++i;
+    }
+    return n;
+}
+template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } };
+template <class Key, class T> class QMutableMapIterator { typedef typename QMap<Key,T>::iterator iterator; typedef typename QMap<Key,T>::const_iterator const_iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableMapIterator() { c->setSharable(true); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QBitArray;
+class QDataStream;
+class QDate;
+class QDateTime;
+class QEasingCurve;
+class QLine;
+class QLineF;
+class QLocale;
+class QMatrix;
+class QTransform;
+class QStringList;
+class QTime;
+class QPoint;
+class QPointF;
+class QSize;
+class QSizeF;
+class QRect;
+class QRectF;
+class QRegExp;
+class QTextFormat;
+class QTextLength;
+class QUrl;
+class QVariant;
+class QVariantComparisonHelper;
+template <typename T>
+inline QVariant qVariantFromValue(const T &);
+template<typename T>
+inline T qvariant_cast(const QVariant &);
+class QVariant
+{
+ public:
+    enum Type {
+        Invalid = 0,
+        Bool = 1,
+        Int = 2,
+        UInt = 3,
+        LongLong = 4,
+        ULongLong = 5,
+        Double = 6,
+        Char = 7,
+        Map = 8,
+        List = 9,
+        String = 10,
+        StringList = 11,
+        ByteArray = 12,
+        BitArray = 13,
+        Date = 14,
+        Time = 15,
+        DateTime = 16,
+        Url = 17,
+        Locale = 18,
+        Rect = 19,
+        RectF = 20,
+        Size = 21,
+        SizeF = 22,
+        Line = 23,
+        LineF = 24,
+        Point = 25,
+        PointF = 26,
+        RegExp = 27,
+        Hash = 28,
+        EasingCurve = 29,
+        LastCoreType = EasingCurve,
+        Font = 64,
+        Pixmap = 65,
+        Brush = 66,
+        Color = 67,
+        Palette = 68,
+        Icon = 69,
+        Image = 70,
+        Polygon = 71,
+        Region = 72,
+        Bitmap = 73,
+        Cursor = 74,
+        SizePolicy = 75,
+        KeySequence = 76,
+        Pen = 77,
+        TextLength = 78,
+        TextFormat = 79,
+        Matrix = 80,
+        Transform = 81,
+        Matrix4x4 = 82,
+        Vector2D = 83,
+        Vector3D = 84,
+        Vector4D = 85,
+        Quaternion = 86,
+        LastGuiType = Quaternion,
+        UserType = 127,
+        LastType = 0xffffffff
+    };
+    inline QVariant();
+    ~QVariant();
+    QVariant(Type type);
+    QVariant(int typeOrUserType, const void *copy);
+    QVariant(int typeOrUserType, const void *copy, uint flags);
+    QVariant(const QVariant &other);
+    QVariant(QDataStream &s);
+    QVariant(int i);
+    QVariant(uint ui);
+    QVariant(qlonglong ll);
+    QVariant(qulonglong ull);
+    QVariant(bool b);
+    QVariant(double d);
+    QVariant(float f) { d.is_null = false; d.type = QMetaType::Float; d.data.f = f; }
+    QVariant(const char *str);
+    QVariant(const QByteArray &bytearray);
+    QVariant(const QBitArray &bitarray);
+    QVariant(const QString &string);
+    QVariant(const QLatin1String &string);
+    QVariant(const QStringList &stringlist);
+    QVariant(const QChar &qchar);
+    QVariant(const QDate &date);
+    QVariant(const QTime &time);
+    QVariant(const QDateTime &datetime);
+    QVariant(const QList<QVariant> &list);
+    QVariant(const QMap<QString,QVariant> &map);
+    QVariant(const QHash<QString,QVariant> &hash);
+    QVariant(const QSize &size);
+    QVariant(const QSizeF &size);
+    QVariant(const QPoint &pt);
+    QVariant(const QPointF &pt);
+    QVariant(const QLine &line);
+    QVariant(const QLineF &line);
+    QVariant(const QRect &rect);
+    QVariant(const QRectF &rect);
+    QVariant(const QUrl &url);
+    QVariant(const QLocale &locale);
+    QVariant(const QRegExp &regExp);
+    QVariant(const QEasingCurve &easing);
+    QVariant(Qt::GlobalColor color);
+    QVariant& operator=(const QVariant &other);
+    inline void swap(QVariant &other) { qSwap(d, other.d); }
+    Type type() const;
+    int userType() const;
+    const char *typeName() const;
+    bool canConvert(Type t) const;
+    bool convert(Type t);
+    inline bool isValid() const;
+    bool isNull() const;
+    void clear();
+    void detach();
+    inline bool isDetached() const;
+    int toInt(bool *ok = 0) const;
+    uint toUInt(bool *ok = 0) const;
+    qlonglong toLongLong(bool *ok = 0) const;
+    qulonglong toULongLong(bool *ok = 0) const;
+    bool toBool() const;
+    double toDouble(bool *ok = 0) const;
+    float toFloat(bool *ok = 0) const;
+    qreal toReal(bool *ok = 0) const;
+    QByteArray toByteArray() const;
+    QBitArray toBitArray() const;
+    QString toString() const;
+    QStringList toStringList() const;
+    QChar toChar() const;
+    QDate toDate() const;
+    QTime toTime() const;
+    QDateTime toDateTime() const;
+    QList<QVariant> toList() const;
+    QMap<QString, QVariant> toMap() const;
+    QHash<QString, QVariant> toHash() const;
+    QPoint toPoint() const;
+    QPointF toPointF() const;
+    QRect toRect() const;
+    QSize toSize() const;
+    QSizeF toSizeF() const;
+    QLine toLine() const;
+    QLineF toLineF() const;
+    QRectF toRectF() const;
+    QUrl toUrl() const;
+    QLocale toLocale() const;
+    QRegExp toRegExp() const;
+    QEasingCurve toEasingCurve() const;
+    void load(QDataStream &ds);
+    void save(QDataStream &ds) const;
+    static const char *typeToName(Type type);
+    static Type nameToType(const char *name);
+    void *data();
+    const void *constData() const;
+    inline const void *data() const { return constData(); }
+    template<typename T>
+    inline void setValue(const T &value);
+    template<typename T>
+    inline T value() const
+    { return qvariant_cast<T>(*this); }
+    template<typename T>
+    static inline QVariant fromValue(const T &value)
+    { return qVariantFromValue(value); }
+    template<typename T>
+    bool canConvert() const
+    { return canConvert(Type(qMetaTypeId<T>())); }
+ public:
+    struct PrivateShared
+    {
+        inline PrivateShared(void *v) : ptr(v), ref(1) { }
+        void *ptr;
+        QAtomicInt ref;
+    };
+    struct Private
+    {
+        inline Private(): type(Invalid), is_shared(false), is_null(true) { data.ptr = 0; }
+        inline Private(const Private &other)
+            : data(other.data), type(other.type),
+              is_shared(other.is_shared), is_null(other.is_null)
+        {}
+        union Data
+        {
+            char c;
+            int i;
+            uint u;
+            bool b;
+            double d;
+            float f;
+            qreal real;
+            qlonglong ll;
+            qulonglong ull;
+            QObject *o;
+            void *ptr;
+            PrivateShared *shared;
+        } data;
+        uint type : 30;
+        uint is_shared : 1;
+        uint is_null : 1;
+    };
+ public:
+    typedef void (*f_construct)(Private *, const void *);
+    typedef void (*f_clear)(Private *);
+    typedef bool (*f_null)(const Private *);
+    typedef void (*f_load)(Private *, QDataStream &);
+    typedef void (*f_save)(const Private *, QDataStream &);
+    typedef bool (*f_compare)(const Private *, const Private *);
+    typedef bool (*f_convert)(const QVariant::Private *d, Type t, void *, bool *);
+    typedef bool (*f_canConvert)(const QVariant::Private *d, Type t);
+    typedef void (*f_debugStream)(QDebug, const QVariant &);
+    struct Handler {
+        f_construct construct;
+        f_clear clear;
+        f_null isNull;
+        f_load load;
+        f_save save;
+        f_compare compare;
+        f_convert convert;
+        f_canConvert canConvert;
+        f_debugStream debugStream;
+    };
+    inline bool operator==(const QVariant &v) const
+    { return cmp(v); }
+    inline bool operator!=(const QVariant &v) const
+    { return !cmp(v); }
+protected:
+    friend inline bool qvariant_cast_helper(const QVariant &, QVariant::Type, void *);
+    friend int qRegisterGuiVariant();
+    friend int qUnregisterGuiVariant();
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+    friend QDebug operator<<(QDebug, const QVariant &);
+    Private d;
+    static const Handler *handler;
+    void create(int type, const void *copy);
+    bool cmp(const QVariant &other) const;
+private:
+    inline QVariant(void *) { qt_noop(); }
+    inline QVariant(bool, int) { qt_noop(); }
+public:
+    typedef Private DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+typedef QList<QVariant> QVariantList;
+typedef QMap<QString, QVariant> QVariantMap;
+typedef QHash<QString, QVariant> QVariantHash;
+inline bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr)
+{ return QVariant::handler->convert(&v.d, tp, ptr, 0); }
+template <typename T>
+inline QVariant qVariantFromValue(const T &t)
+{
+    return QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t, QTypeInfo<T>::isPointer);
+}
+template <>
+inline QVariant qVariantFromValue(const QVariant &t) { return t; }
+template <typename T>
+inline void qVariantSetValue(QVariant &v, const T &t)
+{
+    const uint type = qMetaTypeId<T>(reinterpret_cast<T *>(0));
+    QVariant::Private &d = v.data_ptr();
+    if (v.isDetached() && (type == d.type || (type <= uint(QVariant::Char) && d.type <= uint(QVariant::Char)))) {
+        d.type = type;
+        d.is_null = false;
+        T *old = reinterpret_cast<T*>(d.is_shared ? d.data.shared->ptr : &d.data.ptr);
+        if (QTypeInfo<T>::isComplex)
+            old->~T();
+        new (old) T(t);
+    } else {
+        v = QVariant(type, &t, QTypeInfo<T>::isPointer);
+    }
+}
+template <>
+inline void qVariantSetValue<QVariant>(QVariant &v, const QVariant &t)
+{
+    v = t;
+}
+inline QVariant::QVariant() {}
+inline bool QVariant::isValid() const { return d.type != Invalid; }
+template<typename T>
+inline void QVariant::setValue(const T &avalue)
+{ qVariantSetValue(*this, avalue); }
+ QDataStream& operator>> (QDataStream& s, QVariant& p);
+ QDataStream& operator<< (QDataStream& s, const QVariant& p);
+ QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
+ QDataStream& operator<< (QDataStream& s, const QVariant::Type p);
+inline bool QVariant::isDetached() const
+{ return !d.is_shared || d.data.shared->ref == 1; }
+class QVariantComparisonHelper
+{
+public:
+    inline QVariantComparisonHelper(const QVariant &var)
+        : v(&var) {}
+private:
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+    const QVariant *v;
+};
+inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return v1.cmp(*v2.v);
+}
+inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return !operator==(v1, v2);
+}
+template<typename T> inline T qvariant_cast(const QVariant &v)
+{
+    const int vid = qMetaTypeId<T>(static_cast<T *>(0));
+    if (vid == v.userType())
+        return *reinterpret_cast<const T *>(v.constData());
+    if (vid < int(QMetaType::User)) {
+        T t;
+        if (qvariant_cast_helper(v, QVariant::Type(vid), &t))
+            return t;
+    }
+    return T();
+}
+template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
+{
+    if (v.userType() == QMetaType::QVariant)
+        return *reinterpret_cast<const QVariant *>(v.constData());
+    return v;
+}
+template<typename T>
+inline T qVariantValue(const QVariant &variant)
+{ return qvariant_cast<T>(variant); }
+template<typename T>
+inline bool qVariantCanConvert(const QVariant &variant)
+{ return variant.template canConvert<T>(); }
+template <> inline bool qIsDetached<QVariant>(QVariant &t) { return t.isDetached(); } template <> inline void qSwap<QVariant>(QVariant &value1, QVariant &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QVariant>(::QVariant &value1, ::QVariant &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+template<> class QTypeInfo<QVariant > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QVariant"; } };
+ QDebug operator<<(QDebug, const QVariant &);
+ QDebug operator<<(QDebug, const QVariant::Type);
+ template<> struct QMetaTypeId2<QVariantList> { enum { Defined = 1, MetaType = QMetaType::QVariantList }; static inline int qt_metatype_id() { return QMetaType::QVariantList; } };
+ template<> struct QMetaTypeId2<QVariantMap> { enum { Defined = 1, MetaType = QMetaType::QVariantMap }; static inline int qt_metatype_id() { return QMetaType::QVariantMap; } };
+ template<> struct QMetaTypeId2<QVariantHash> { enum { Defined = 1, MetaType = QMetaType::QVariantHash }; static inline int qt_metatype_id() { return QMetaType::QVariantHash; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDataStream;
+class QDate;
+class QDateTime;
+class QTime;
+class QVariant;
+class QTextStream;
+class QTextStreamPrivate;
+class QLocale;
+class QSystemLocale
+{
+public:
+    QSystemLocale();
+    virtual ~QSystemLocale();
+    struct CurrencyToStringArgument
+    {
+        CurrencyToStringArgument() { }
+        CurrencyToStringArgument(const QVariant &v, const QString &s)
+            : value(v), symbol(s) { }
+        QVariant value;
+        QString symbol;
+    };
+    enum QueryType {
+        LanguageId,
+        CountryId,
+        DecimalPoint,
+        GroupSeparator,
+        ZeroDigit,
+        NegativeSign,
+        DateFormatLong,
+        DateFormatShort,
+        TimeFormatLong,
+        TimeFormatShort,
+        DayNameLong,
+        DayNameShort,
+        MonthNameLong,
+        MonthNameShort,
+        DateToStringLong,
+        DateToStringShort,
+        TimeToStringLong,
+        TimeToStringShort,
+        DateTimeFormatLong,
+        DateTimeFormatShort,
+        DateTimeToStringLong,
+        DateTimeToStringShort,
+        MeasurementSystem,
+        PositiveSign,
+        AMText,
+        PMText,
+        FirstDayOfWeek,
+        Weekdays,
+        CurrencySymbol,
+        CurrencyToString,
+        UILanguages,
+        StringToStandardQuotation,
+        StringToAlternateQuotation,
+        ScriptId,
+        ListToSeparatedString,
+        LocaleChanged,
+        NativeLanguageName,
+        NativeCountryName
+    };
+    virtual QVariant query(QueryType type, QVariant in) const;
+    virtual QLocale fallbackLocale() const;
+private:
+    QSystemLocale(bool);
+    friend QSystemLocale *QSystemLocale_globalSystemLocale();
+};
+struct QLocalePrivate;
+class QLocale
+{
+    public: static const QMetaObject staticMetaObject; private:
+    friend class QString;
+    friend class QByteArray;
+    friend class QIntValidator;
+    friend class QDoubleValidatorPrivate;
+    friend class QTextStream;
+    friend class QTextStreamPrivate;
+public:
+    enum Language {
+        AnyLanguage = 0,
+        C = 1,
+        Abkhazian = 2,
+        Afan = 3,
+        Afar = 4,
+        Afrikaans = 5,
+        Albanian = 6,
+        Amharic = 7,
+        Arabic = 8,
+        Armenian = 9,
+        Assamese = 10,
+        Aymara = 11,
+        Azerbaijani = 12,
+        Bashkir = 13,
+        Basque = 14,
+        Bengali = 15,
+        Bhutani = 16,
+        Bihari = 17,
+        Bislama = 18,
+        Breton = 19,
+        Bulgarian = 20,
+        Burmese = 21,
+        Byelorussian = 22,
+        Cambodian = 23,
+        Catalan = 24,
+        Chinese = 25,
+        Corsican = 26,
+        Croatian = 27,
+        Czech = 28,
+        Danish = 29,
+        Dutch = 30,
+        English = 31,
+        Esperanto = 32,
+        Estonian = 33,
+        Faroese = 34,
+        FijiLanguage = 35,
+        Finnish = 36,
+        French = 37,
+        Frisian = 38,
+        Gaelic = 39,
+        Galician = 40,
+        Georgian = 41,
+        German = 42,
+        Greek = 43,
+        Greenlandic = 44,
+        Guarani = 45,
+        Gujarati = 46,
+        Hausa = 47,
+        Hebrew = 48,
+        Hindi = 49,
+        Hungarian = 50,
+        Icelandic = 51,
+        Indonesian = 52,
+        Interlingua = 53,
+        Interlingue = 54,
+        Inuktitut = 55,
+        Inupiak = 56,
+        Irish = 57,
+        Italian = 58,
+        Japanese = 59,
+        Javanese = 60,
+        Kannada = 61,
+        Kashmiri = 62,
+        Kazakh = 63,
+        Kinyarwanda = 64,
+        Kirghiz = 65,
+        Korean = 66,
+        Kurdish = 67,
+        Rundi = 68,
+        Laothian = 69,
+        Latin = 70,
+        Latvian = 71,
+        Lingala = 72,
+        Lithuanian = 73,
+        Macedonian = 74,
+        Malagasy = 75,
+        Malay = 76,
+        Malayalam = 77,
+        Maltese = 78,
+        Maori = 79,
+        Marathi = 80,
+        Moldavian = 81,
+        Mongolian = 82,
+        NauruLanguage = 83,
+        Nepali = 84,
+        Norwegian = 85,
+        Occitan = 86,
+        Oriya = 87,
+        Pashto = 88,
+        Persian = 89,
+        Polish = 90,
+        Portuguese = 91,
+        Punjabi = 92,
+        Quechua = 93,
+        RhaetoRomance = 94,
+        Romanian = 95,
+        Russian = 96,
+        Samoan = 97,
+        Sangho = 98,
+        Sanskrit = 99,
+        Serbian = 100,
+        SerboCroatian = 101,
+        Sesotho = 102,
+        Setswana = 103,
+        Shona = 104,
+        Sindhi = 105,
+        Singhalese = 106,
+        Siswati = 107,
+        Slovak = 108,
+        Slovenian = 109,
+        Somali = 110,
+        Spanish = 111,
+        Sundanese = 112,
+        Swahili = 113,
+        Swedish = 114,
+        Tagalog = 115,
+        Tajik = 116,
+        Tamil = 117,
+        Tatar = 118,
+        Telugu = 119,
+        Thai = 120,
+        Tibetan = 121,
+        Tigrinya = 122,
+        TongaLanguage = 123,
+        Tsonga = 124,
+        Turkish = 125,
+        Turkmen = 126,
+        Twi = 127,
+        Uigur = 128,
+        Ukrainian = 129,
+        Urdu = 130,
+        Uzbek = 131,
+        Vietnamese = 132,
+        Volapuk = 133,
+        Welsh = 134,
+        Wolof = 135,
+        Xhosa = 136,
+        Yiddish = 137,
+        Yoruba = 138,
+        Zhuang = 139,
+        Zulu = 140,
+        Nynorsk = 141,
+        Bosnian = 142,
+        Divehi = 143,
+        Manx = 144,
+        Cornish = 145,
+        Akan = 146,
+        Konkani = 147,
+        Ga = 148,
+        Igbo = 149,
+        Kamba = 150,
+        Syriac = 151,
+        Blin = 152,
+        Geez = 153,
+        Koro = 154,
+        Sidamo = 155,
+        Atsam = 156,
+        Tigre = 157,
+        Jju = 158,
+        Friulian = 159,
+        Venda = 160,
+        Ewe = 161,
+        Walamo = 162,
+        Hawaiian = 163,
+        Tyap = 164,
+        Chewa = 165,
+        Filipino = 166,
+        SwissGerman = 167,
+        SichuanYi = 168,
+        Kpelle = 169,
+        LowGerman = 170,
+        SouthNdebele = 171,
+        NorthernSotho = 172,
+        NorthernSami = 173,
+        Taroko = 174,
+        Gusii = 175,
+        Taita = 176,
+        Fulah = 177,
+        Kikuyu = 178,
+        Samburu = 179,
+        Sena = 180,
+        NorthNdebele = 181,
+        Rombo = 182,
+        Tachelhit = 183,
+        Kabyle = 184,
+        Nyankole = 185,
+        Bena = 186,
+        Vunjo = 187,
+        Bambara = 188,
+        Embu = 189,
+        Cherokee = 190,
+        Morisyen = 191,
+        Makonde = 192,
+        Langi = 193,
+        Ganda = 194,
+        Bemba = 195,
+        Kabuverdianu = 196,
+        Meru = 197,
+        Kalenjin = 198,
+        Nama = 199,
+        Machame = 200,
+        Colognian = 201,
+        Masai = 202,
+        Soga = 203,
+        Luyia = 204,
+        Asu = 205,
+        Teso = 206,
+        Saho = 207,
+        KoyraChiini = 208,
+        Rwa = 209,
+        Luo = 210,
+        Chiga = 211,
+        CentralMoroccoTamazight = 212,
+        KoyraboroSenni = 213,
+        Shambala = 214,
+        Bodo = 215,
+        Aghem = 216,
+        Basaa = 217,
+        Zarma = 218,
+        Duala = 219,
+        JolaFonyi = 220,
+        Ewondo = 221,
+        Bafia = 222,
+        LubaKatanga = 223,
+        MakhuwaMeetto = 224,
+        Mundang = 225,
+        Kwasio = 226,
+        Nuer = 227,
+        Sakha = 228,
+        Sangu = 229,
+        CongoSwahili = 230,
+        Tasawaq = 231,
+        Vai = 232,
+        Walser = 233,
+        Yangben = 234,
+        NorwegianBokmal = Norwegian,
+        NorwegianNynorsk = Nynorsk,
+        Kurundi = Rundi,
+        LastLanguage = Yangben
+    };
+    enum Script {
+        AnyScript = 0,
+        ArabicScript = 1,
+        CyrillicScript = 2,
+        DeseretScript = 3,
+        GurmukhiScript = 4,
+        SimplifiedHanScript = 5,
+        TraditionalHanScript = 6,
+        LatinScript = 7,
+        MongolianScript = 8,
+        TifinaghScript = 9,
+        SimplifiedChineseScript = SimplifiedHanScript,
+        TraditionalChineseScript = TraditionalHanScript,
+        LastScript = TifinaghScript
+    };
+    enum Country {
+        AnyCountry = 0,
+        Afghanistan = 1,
+        Albania = 2,
+        Algeria = 3,
+        AmericanSamoa = 4,
+        Andorra = 5,
+        Angola = 6,
+        Anguilla = 7,
+        Antarctica = 8,
+        AntiguaAndBarbuda = 9,
+        Argentina = 10,
+        Armenia = 11,
+        Aruba = 12,
+        Australia = 13,
+        Austria = 14,
+        Azerbaijan = 15,
+        Bahamas = 16,
+        Bahrain = 17,
+        Bangladesh = 18,
+        Barbados = 19,
+        Belarus = 20,
+        Belgium = 21,
+        Belize = 22,
+        Benin = 23,
+        Bermuda = 24,
+        Bhutan = 25,
+        Bolivia = 26,
+        BosniaAndHerzegowina = 27,
+        Botswana = 28,
+        BouvetIsland = 29,
+        Brazil = 30,
+        BritishIndianOceanTerritory = 31,
+        BruneiDarussalam = 32,
+        Bulgaria = 33,
+        BurkinaFaso = 34,
+        Burundi = 35,
+        Cambodia = 36,
+        Cameroon = 37,
+        Canada = 38,
+        CapeVerde = 39,
+        CaymanIslands = 40,
+        CentralAfricanRepublic = 41,
+        Chad = 42,
+        Chile = 43,
+        China = 44,
+        ChristmasIsland = 45,
+        CocosIslands = 46,
+        Colombia = 47,
+        Comoros = 48,
+        DemocraticRepublicOfCongo = 49,
+        PeoplesRepublicOfCongo = 50,
+        CookIslands = 51,
+        CostaRica = 52,
+        IvoryCoast = 53,
+        Croatia = 54,
+        Cuba = 55,
+        Cyprus = 56,
+        CzechRepublic = 57,
+        Denmark = 58,
+        Djibouti = 59,
+        Dominica = 60,
+        DominicanRepublic = 61,
+        EastTimor = 62,
+        Ecuador = 63,
+        Egypt = 64,
+        ElSalvador = 65,
+        EquatorialGuinea = 66,
+        Eritrea = 67,
+        Estonia = 68,
+        Ethiopia = 69,
+        FalklandIslands = 70,
+        FaroeIslands = 71,
+        FijiCountry = 72,
+        Finland = 73,
+        France = 74,
+        MetropolitanFrance = 75,
+        FrenchGuiana = 76,
+        FrenchPolynesia = 77,
+        FrenchSouthernTerritories = 78,
+        Gabon = 79,
+        Gambia = 80,
+        Georgia = 81,
+        Germany = 82,
+        Ghana = 83,
+        Gibraltar = 84,
+        Greece = 85,
+        Greenland = 86,
+        Grenada = 87,
+        Guadeloupe = 88,
+        Guam = 89,
+        Guatemala = 90,
+        Guinea = 91,
+        GuineaBissau = 92,
+        Guyana = 93,
+        Haiti = 94,
+        HeardAndMcDonaldIslands = 95,
+        Honduras = 96,
+        HongKong = 97,
+        Hungary = 98,
+        Iceland = 99,
+        India = 100,
+        Indonesia = 101,
+        Iran = 102,
+        Iraq = 103,
+        Ireland = 104,
+        Israel = 105,
+        Italy = 106,
+        Jamaica = 107,
+        Japan = 108,
+        Jordan = 109,
+        Kazakhstan = 110,
+        Kenya = 111,
+        Kiribati = 112,
+        DemocraticRepublicOfKorea = 113,
+        RepublicOfKorea = 114,
+        Kuwait = 115,
+        Kyrgyzstan = 116,
+        Lao = 117,
+        Latvia = 118,
+        Lebanon = 119,
+        Lesotho = 120,
+        Liberia = 121,
+        LibyanArabJamahiriya = 122,
+        Liechtenstein = 123,
+        Lithuania = 124,
+        Luxembourg = 125,
+        Macau = 126,
+        Macedonia = 127,
+        Madagascar = 128,
+        Malawi = 129,
+        Malaysia = 130,
+        Maldives = 131,
+        Mali = 132,
+        Malta = 133,
+        MarshallIslands = 134,
+        Martinique = 135,
+        Mauritania = 136,
+        Mauritius = 137,
+        Mayotte = 138,
+        Mexico = 139,
+        Micronesia = 140,
+        Moldova = 141,
+        Monaco = 142,
+        Mongolia = 143,
+        Montserrat = 144,
+        Morocco = 145,
+        Mozambique = 146,
+        Myanmar = 147,
+        Namibia = 148,
+        NauruCountry = 149,
+        Nepal = 150,
+        Netherlands = 151,
+        NetherlandsAntilles = 152,
+        NewCaledonia = 153,
+        NewZealand = 154,
+        Nicaragua = 155,
+        Niger = 156,
+        Nigeria = 157,
+        Niue = 158,
+        NorfolkIsland = 159,
+        NorthernMarianaIslands = 160,
+        Norway = 161,
+        Oman = 162,
+        Pakistan = 163,
+        Palau = 164,
+        PalestinianTerritory = 165,
+        Panama = 166,
+        PapuaNewGuinea = 167,
+        Paraguay = 168,
+        Peru = 169,
+        Philippines = 170,
+        Pitcairn = 171,
+        Poland = 172,
+        Portugal = 173,
+        PuertoRico = 174,
+        Qatar = 175,
+        Reunion = 176,
+        Romania = 177,
+        RussianFederation = 178,
+        Rwanda = 179,
+        SaintKittsAndNevis = 180,
+        StLucia = 181,
+        StVincentAndTheGrenadines = 182,
+        Samoa = 183,
+        SanMarino = 184,
+        SaoTomeAndPrincipe = 185,
+        SaudiArabia = 186,
+        Senegal = 187,
+        Seychelles = 188,
+        SierraLeone = 189,
+        Singapore = 190,
+        Slovakia = 191,
+        Slovenia = 192,
+        SolomonIslands = 193,
+        Somalia = 194,
+        SouthAfrica = 195,
+        SouthGeorgiaAndTheSouthSandwichIslands = 196,
+        Spain = 197,
+        SriLanka = 198,
+        StHelena = 199,
+        StPierreAndMiquelon = 200,
+        Sudan = 201,
+        Suriname = 202,
+        SvalbardAndJanMayenIslands = 203,
+        Swaziland = 204,
+        Sweden = 205,
+        Switzerland = 206,
+        SyrianArabRepublic = 207,
+        Taiwan = 208,
+        Tajikistan = 209,
+        Tanzania = 210,
+        Thailand = 211,
+        Togo = 212,
+        Tokelau = 213,
+        TongaCountry = 214,
+        TrinidadAndTobago = 215,
+        Tunisia = 216,
+        Turkey = 217,
+        Turkmenistan = 218,
+        TurksAndCaicosIslands = 219,
+        Tuvalu = 220,
+        Uganda = 221,
+        Ukraine = 222,
+        UnitedArabEmirates = 223,
+        UnitedKingdom = 224,
+        UnitedStates = 225,
+        UnitedStatesMinorOutlyingIslands = 226,
+        Uruguay = 227,
+        Uzbekistan = 228,
+        Vanuatu = 229,
+        VaticanCityState = 230,
+        Venezuela = 231,
+        VietNam = 232,
+        BritishVirginIslands = 233,
+        USVirginIslands = 234,
+        WallisAndFutunaIslands = 235,
+        WesternSahara = 236,
+        Yemen = 237,
+        Yugoslavia = 238,
+        Zambia = 239,
+        Zimbabwe = 240,
+        SerbiaAndMontenegro = 241,
+        Montenegro = 242,
+        Serbia = 243,
+        SaintBarthelemy = 244,
+        SaintMartin = 245,
+        LatinAmericaAndTheCaribbean = 246,
+        LastCountry = LatinAmericaAndTheCaribbean
+    };
+    enum MeasurementSystem { MetricSystem, ImperialSystem };
+    enum FormatType { LongFormat, ShortFormat, NarrowFormat };
+    enum NumberOption {
+        OmitGroupSeparator = 0x01,
+        RejectGroupSeparator = 0x02
+    };
+    typedef QFlags<NumberOption> NumberOptions;
+    enum CurrencySymbolFormat {
+        CurrencyIsoCode,
+        CurrencySymbol,
+        CurrencyDisplayName
+    };
+    QLocale();
+    QLocale(const QString &name);
+    QLocale(Language language, Country country = AnyCountry);
+    QLocale(Language language, Script script, Country country);
+    QLocale(const QLocale &other);
+    QLocale &operator=(const QLocale &other);
+    Language language() const;
+    Script script() const;
+    Country country() const;
+    QString name() const;
+    QString bcp47Name() const;
+    QString nativeLanguageName() const;
+    QString nativeCountryName() const;
+    short toShort(const QString &s, bool *ok = 0, int base = 0) const;
+    ushort toUShort(const QString &s, bool *ok = 0, int base = 0) const;
+    int toInt(const QString &s, bool *ok = 0, int base = 0) const;
+    uint toUInt(const QString &s, bool *ok = 0, int base = 0) const;
+    qlonglong toLongLong(const QString &s, bool *ok = 0, int base = 0) const;
+    qlonglong toULongLong(const QString &s, bool *ok = 0, int base = 0) const;
+    float toFloat(const QString &s, bool *ok = 0) const;
+    double toDouble(const QString &s, bool *ok = 0) const;
+    QString toString(qlonglong i) const;
+    QString toString(qulonglong i) const;
+    inline QString toString(short i) const;
+    inline QString toString(ushort i) const;
+    inline QString toString(int i) const;
+    inline QString toString(uint i) const;
+    QString toString(double i, char f = 'g', int prec = 6) const;
+    inline QString toString(float i, char f = 'g', int prec = 6) const;
+    QString toString(const QDate &date, const QString &formatStr) const;
+    QString toString(const QDate &date, FormatType format = LongFormat) const;
+    QString toString(const QTime &time, const QString &formatStr) const;
+    QString toString(const QTime &time, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, const QString &format) const;
+    QString dateFormat(FormatType format = LongFormat) const;
+    QString timeFormat(FormatType format = LongFormat) const;
+    QString dateTimeFormat(FormatType format = LongFormat) const;
+    QDate toDate(const QString &string, FormatType = LongFormat) const;
+    QTime toTime(const QString &string, FormatType = LongFormat) const;
+    QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const;
+    QDate toDate(const QString &string, const QString &format) const;
+    QTime toTime(const QString &string, const QString &format) const;
+    QDateTime toDateTime(const QString &string, const QString &format) const;
+    QChar decimalPoint() const;
+    QChar groupSeparator() const;
+    QChar percent() const;
+    QChar zeroDigit() const;
+    QChar negativeSign() const;
+    QChar positiveSign() const;
+    QChar exponential() const;
+    QString monthName(int, FormatType format = LongFormat) const;
+    QString standaloneMonthName(int, FormatType format = LongFormat) const;
+    QString dayName(int, FormatType format = LongFormat) const;
+    QString standaloneDayName(int, FormatType format = LongFormat) const;
+    Qt::DayOfWeek firstDayOfWeek() const;
+    QList<Qt::DayOfWeek> weekdays() const;
+    QString amText() const;
+    QString pmText() const;
+    MeasurementSystem measurementSystem() const;
+    Qt::LayoutDirection textDirection() const;
+    QString toUpper(const QString &str) const;
+    QString toLower(const QString &str) const;
+    QString currencySymbol(CurrencySymbolFormat = CurrencySymbol) const;
+    QString toCurrencyString(qlonglong, const QString &symbol = QString()) const;
+    QString toCurrencyString(qulonglong, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(short, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(ushort, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(int, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(uint, const QString &symbol = QString()) const;
+    QString toCurrencyString(double, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(float, const QString &symbol = QString()) const;
+    QStringList uiLanguages() const;
+    inline bool operator==(const QLocale &other) const;
+    inline bool operator!=(const QLocale &other) const;
+    static QString languageToString(Language language);
+    static QString countryToString(Country country);
+    static QString scriptToString(Script script);
+    static void setDefault(const QLocale &locale);
+    static QLocale c() { return QLocale(C); }
+    static QLocale system();
+    static QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Country country);
+    static QList<Country> countriesForLanguage(Language lang);
+    void setNumberOptions(NumberOptions options);
+    NumberOptions numberOptions() const;
+    enum QuotationStyle { StandardQuotation, AlternateQuotation };
+    QString quoteString(const QString &str, QuotationStyle style = StandardQuotation) const;
+    QString quoteString(const QStringRef &str, QuotationStyle style = StandardQuotation) const;
+    QString createSeparatedList(const QStringList &strl) const;
+    struct Data {
+        quint16 index;
+        quint16 numberOptions;
+    }
+    __attribute__ ((__packed__))
+    ;
+private:
+    friend struct QLocalePrivate;
+    union {
+        void *v;
+        Data p;
+    };
+    const QLocalePrivate *d() const;
+};
+template<> class QTypeInfo<QLocale > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLocale"; } };
+ inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QString QLocale::toString(short i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(ushort i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(int i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(uint i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(float i, char f, int prec) const
+    { return toString(double(i), f, prec); }
+inline bool QLocale::operator==(const QLocale &other) const
+    { return d() == other.d() && numberOptions() == other.numberOptions(); }
+inline bool QLocale::operator!=(const QLocale &other) const
+    { return d() != other.d() || numberOptions() != other.numberOptions(); }
+inline QString QLocale::toCurrencyString(short i, const QString &symbol) const
+    { return toCurrencyString(qlonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(ushort i, const QString &symbol) const
+    { return toCurrencyString(qulonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(int i, const QString &symbol) const
+{ return toCurrencyString(qlonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(uint i, const QString &symbol) const
+{ return toCurrencyString(qulonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(float i, const QString &symbol) const
+{ return toCurrencyString(double(i), symbol); }
+ QDataStream &operator<<(QDataStream &, const QLocale &);
+ QDataStream &operator>>(QDataStream &, QLocale &);
+ template <> struct QMetaTypeId< QSystemLocale::CurrencyToStringArgument > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id) metatype_id = qRegisterMetaType< QSystemLocale::CurrencyToStringArgument >("QSystemLocale::CurrencyToStringArgument", reinterpret_cast< QSystemLocale::CurrencyToStringArgument *>(quintptr(-1))); return metatype_id; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QMargins
+{
+public:
+    QMargins();
+    QMargins(int left, int top, int right, int bottom);
+    bool isNull() const;
+    int left() const;
+    int top() const;
+    int right() const;
+    int bottom() const;
+    void setLeft(int left);
+    void setTop(int top);
+    void setRight(int right);
+    void setBottom(int bottom);
+private:
+    int m_left;
+    int m_top;
+    int m_right;
+    int m_bottom;
+    friend inline bool operator==(const QMargins &, const QMargins &);
+    friend inline bool operator!=(const QMargins &, const QMargins &);
+};
+template<> class QTypeInfo<QMargins > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMargins)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMargins"; } };
+inline QMargins::QMargins()
+{ m_top = m_bottom = m_left = m_right = 0; }
+inline QMargins::QMargins(int aleft, int atop, int aright, int abottom)
+    : m_left(aleft), m_top(atop), m_right(aright), m_bottom(abottom) {}
+inline bool QMargins::isNull() const
+{ return m_left==0 && m_top==0 && m_right==0 && m_bottom==0; }
+inline int QMargins::left() const
+{ return m_left; }
+inline int QMargins::top() const
+{ return m_top; }
+inline int QMargins::right() const
+{ return m_right; }
+inline int QMargins::bottom() const
+{ return m_bottom; }
+inline void QMargins::setLeft(int aleft)
+{ m_left = aleft; }
+inline void QMargins::setTop(int atop)
+{ m_top = atop; }
+inline void QMargins::setRight(int aright)
+{ m_right = aright; }
+inline void QMargins::setBottom(int abottom)
+{ m_bottom = abottom; }
+inline bool operator==(const QMargins &m1, const QMargins &m2)
+{
+    return
+            m1.m_left == m2.m_left &&
+            m1.m_top == m2.m_top &&
+            m1.m_right == m2.m_right &&
+            m1.m_bottom == m2.m_bottom;
+}
+inline bool operator!=(const QMargins &m1, const QMargins &m2)
+{
+    return
+            m1.m_left != m2.m_left ||
+            m1.m_top != m2.m_top ||
+            m1.m_right != m2.m_right ||
+            m1.m_bottom != m2.m_bottom;
+}
+ QDebug operator<<(QDebug, const QMargins &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T>
+class QQueue : public QList<T>
+{
+public:
+    inline QQueue() {}
+    inline ~QQueue() {}
+    inline void swap(QQueue<T> &other) { QList<T>::swap(other); }
+    inline void enqueue(const T &t) { QList<T>::append(t); }
+    inline T dequeue() { return QList<T>::takeFirst(); }
+    inline T &head() { return QList<T>::first(); }
+    inline const T &head() const { return QList<T>::first(); }
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSize
+{
+public:
+    QSize();
+    QSize(int w, int h);
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+    int width() const;
+    int height() const;
+    void setWidth(int w);
+    void setHeight(int h);
+    void transpose();
+    void scale(int w, int h, Qt::AspectRatioMode mode);
+    void scale(const QSize &s, Qt::AspectRatioMode mode);
+    QSize expandedTo(const QSize &) const;
+    QSize boundedTo(const QSize &) const;
+    int &rwidth();
+    int &rheight();
+    QSize &operator+=(const QSize &);
+    QSize &operator-=(const QSize &);
+    QSize &operator*=(qreal c);
+    QSize &operator/=(qreal c);
+    friend inline bool operator==(const QSize &, const QSize &);
+    friend inline bool operator!=(const QSize &, const QSize &);
+    friend inline const QSize operator+(const QSize &, const QSize &);
+    friend inline const QSize operator-(const QSize &, const QSize &);
+    friend inline const QSize operator*(const QSize &, qreal);
+    friend inline const QSize operator*(qreal, const QSize &);
+    friend inline const QSize operator/(const QSize &, qreal);
+private:
+    int wd;
+    int ht;
+};
+template<> class QTypeInfo<QSize > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSize"; } };
+ QDataStream &operator<<(QDataStream &, const QSize &);
+ QDataStream &operator>>(QDataStream &, QSize &);
+inline QSize::QSize()
+{ wd = ht = -1; }
+inline QSize::QSize(int w, int h)
+{ wd = w; ht = h; }
+inline bool QSize::isNull() const
+{ return wd==0 && ht==0; }
+inline bool QSize::isEmpty() const
+{ return wd<1 || ht<1; }
+inline bool QSize::isValid() const
+{ return wd>=0 && ht>=0; }
+inline int QSize::width() const
+{ return wd; }
+inline int QSize::height() const
+{ return ht; }
+inline void QSize::setWidth(int w)
+{ wd = w; }
+inline void QSize::setHeight(int h)
+{ ht = h; }
+inline void QSize::scale(int w, int h, Qt::AspectRatioMode mode)
+{ scale(QSize(w, h), mode); }
+inline int &QSize::rwidth()
+{ return wd; }
+inline int &QSize::rheight()
+{ return ht; }
+inline QSize &QSize::operator+=(const QSize &s)
+{ wd+=s.wd; ht+=s.ht; return *this; }
+inline QSize &QSize::operator-=(const QSize &s)
+{ wd-=s.wd; ht-=s.ht; return *this; }
+inline QSize &QSize::operator*=(qreal c)
+{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
+inline bool operator==(const QSize &s1, const QSize &s2)
+{ return s1.wd == s2.wd && s1.ht == s2.ht; }
+inline bool operator!=(const QSize &s1, const QSize &s2)
+{ return s1.wd != s2.wd || s1.ht != s2.ht; }
+inline const QSize operator+(const QSize & s1, const QSize & s2)
+{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); }
+inline const QSize operator-(const QSize &s1, const QSize &s2)
+{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); }
+inline const QSize operator*(const QSize &s, qreal c)
+{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+inline const QSize operator*(qreal c, const QSize &s)
+{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+inline QSize &QSize::operator/=(qreal c)
+{
+    qt_noop();
+    wd = qRound(wd/c); ht = qRound(ht/c);
+    return *this;
+}
+inline const QSize operator/(const QSize &s, qreal c)
+{
+    qt_noop();
+    return QSize(qRound(s.wd/c), qRound(s.ht/c));
+}
+inline QSize QSize::expandedTo(const QSize & otherSize) const
+{
+    return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
+}
+inline QSize QSize::boundedTo(const QSize & otherSize) const
+{
+    return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
+}
+ QDebug operator<<(QDebug, const QSize &);
+class QSizeF
+{
+public:
+    QSizeF();
+    QSizeF(const QSize &sz);
+    QSizeF(qreal w, qreal h);
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+    qreal width() const;
+    qreal height() const;
+    void setWidth(qreal w);
+    void setHeight(qreal h);
+    void transpose();
+    void scale(qreal w, qreal h, Qt::AspectRatioMode mode);
+    void scale(const QSizeF &s, Qt::AspectRatioMode mode);
+    QSizeF expandedTo(const QSizeF &) const;
+    QSizeF boundedTo(const QSizeF &) const;
+    qreal &rwidth();
+    qreal &rheight();
+    QSizeF &operator+=(const QSizeF &);
+    QSizeF &operator-=(const QSizeF &);
+    QSizeF &operator*=(qreal c);
+    QSizeF &operator/=(qreal c);
+    friend inline bool operator==(const QSizeF &, const QSizeF &);
+    friend inline bool operator!=(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator+(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator-(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator*(const QSizeF &, qreal);
+    friend inline const QSizeF operator*(qreal, const QSizeF &);
+    friend inline const QSizeF operator/(const QSizeF &, qreal);
+    inline QSize toSize() const;
+private:
+    qreal wd;
+    qreal ht;
+};
+template<> class QTypeInfo<QSizeF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSizeF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSizeF"; } };
+ QDataStream &operator<<(QDataStream &, const QSizeF &);
+ QDataStream &operator>>(QDataStream &, QSizeF &);
+inline QSizeF::QSizeF()
+{ wd = ht = -1.; }
+inline QSizeF::QSizeF(const QSize &sz)
+    : wd(sz.width()), ht(sz.height())
+{
+}
+inline QSizeF::QSizeF(qreal w, qreal h)
+{ wd = w; ht = h; }
+inline bool QSizeF::isNull() const
+{ return qIsNull(wd) && qIsNull(ht); }
+inline bool QSizeF::isEmpty() const
+{ return wd <= 0. || ht <= 0.; }
+inline bool QSizeF::isValid() const
+{ return wd >= 0. && ht >= 0.; }
+inline qreal QSizeF::width() const
+{ return wd; }
+inline qreal QSizeF::height() const
+{ return ht; }
+inline void QSizeF::setWidth(qreal w)
+{ wd = w; }
+inline void QSizeF::setHeight(qreal h)
+{ ht = h; }
+inline void QSizeF::scale(qreal w, qreal h, Qt::AspectRatioMode mode)
+{ scale(QSizeF(w, h), mode); }
+inline qreal &QSizeF::rwidth()
+{ return wd; }
+inline qreal &QSizeF::rheight()
+{ return ht; }
+inline QSizeF &QSizeF::operator+=(const QSizeF &s)
+{ wd += s.wd; ht += s.ht; return *this; }
+inline QSizeF &QSizeF::operator-=(const QSizeF &s)
+{ wd -= s.wd; ht -= s.ht; return *this; }
+inline QSizeF &QSizeF::operator*=(qreal c)
+{ wd *= c; ht *= c; return *this; }
+inline bool operator==(const QSizeF &s1, const QSizeF &s2)
+{ return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); }
+inline bool operator!=(const QSizeF &s1, const QSizeF &s2)
+{ return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); }
+inline const QSizeF operator+(const QSizeF & s1, const QSizeF & s2)
+{ return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); }
+inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2)
+{ return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); }
+inline const QSizeF operator*(const QSizeF &s, qreal c)
+{ return QSizeF(s.wd*c, s.ht*c); }
+inline const QSizeF operator*(qreal c, const QSizeF &s)
+{ return QSizeF(s.wd*c, s.ht*c); }
+inline QSizeF &QSizeF::operator/=(qreal c)
+{
+    qt_noop();
+    wd = wd/c; ht = ht/c;
+    return *this;
+}
+inline const QSizeF operator/(const QSizeF &s, qreal c)
+{
+    qt_noop();
+    return QSizeF(s.wd/c, s.ht/c);
+}
+inline QSizeF QSizeF::expandedTo(const QSizeF & otherSize) const
+{
+    return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
+}
+inline QSizeF QSizeF::boundedTo(const QSizeF & otherSize) const
+{
+    return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
+}
+inline QSize QSizeF::toSize() const
+{
+    return QSize(qRound(wd), qRound(ht));
+}
+ QDebug operator<<(QDebug, const QSizeF &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QRect
+{
+public:
+    QRect() { x1 = y1 = 0; x2 = y2 = -1; }
+    QRect(const QPoint &topleft, const QPoint &bottomright);
+    QRect(const QPoint &topleft, const QSize &size);
+    QRect(int left, int top, int width, int height);
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+    int left() const;
+    int top() const;
+    int right() const;
+    int bottom() const;
+    QRect normalized() const;
+    int x() const;
+    int y() const;
+    void setLeft(int pos);
+    void setTop(int pos);
+    void setRight(int pos);
+    void setBottom(int pos);
+    void setX(int x);
+    void setY(int y);
+    void setTopLeft(const QPoint &p);
+    void setBottomRight(const QPoint &p);
+    void setTopRight(const QPoint &p);
+    void setBottomLeft(const QPoint &p);
+    QPoint topLeft() const;
+    QPoint bottomRight() const;
+    QPoint topRight() const;
+    QPoint bottomLeft() const;
+    QPoint center() const;
+    void moveLeft(int pos);
+    void moveTop(int pos);
+    void moveRight(int pos);
+    void moveBottom(int pos);
+    void moveTopLeft(const QPoint &p);
+    void moveBottomRight(const QPoint &p);
+    void moveTopRight(const QPoint &p);
+    void moveBottomLeft(const QPoint &p);
+    void moveCenter(const QPoint &p);
+    inline void translate(int dx, int dy);
+    inline void translate(const QPoint &p);
+    inline QRect translated(int dx, int dy) const;
+    inline QRect translated(const QPoint &p) const;
+    void moveTo(int x, int t);
+    void moveTo(const QPoint &p);
+    void setRect(int x, int y, int w, int h);
+    inline void getRect(int *x, int *y, int *w, int *h) const;
+    void setCoords(int x1, int y1, int x2, int y2);
+    inline void getCoords(int *x1, int *y1, int *x2, int *y2) const;
+    inline void adjust(int x1, int y1, int x2, int y2);
+    inline QRect adjusted(int x1, int y1, int x2, int y2) const;
+    QSize size() const;
+    int width() const;
+    int height() const;
+    void setWidth(int w);
+    void setHeight(int h);
+    void setSize(const QSize &s);
+    QRect operator|(const QRect &r) const;
+    QRect operator&(const QRect &r) const;
+    QRect& operator|=(const QRect &r);
+    QRect& operator&=(const QRect &r);
+    bool contains(const QPoint &p, bool proper=false) const;
+    bool contains(int x, int y) const;
+    bool contains(int x, int y, bool proper) const;
+    bool contains(const QRect &r, bool proper = false) const;
+    QRect unite(const QRect &r) const;
+    QRect united(const QRect &other) const;
+    QRect intersect(const QRect &r) const;
+    QRect intersected(const QRect &other) const;
+    bool intersects(const QRect &r) const;
+    friend inline bool operator==(const QRect &, const QRect &);
+    friend inline bool operator!=(const QRect &, const QRect &);
+private:
+    friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2);
+    int x1;
+    int y1;
+    int x2;
+    int y2;
+};
+template<> class QTypeInfo<QRect > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRect)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRect"; } };
+ inline bool operator==(const QRect &, const QRect &);
+ inline bool operator!=(const QRect &, const QRect &);
+ QDataStream &operator<<(QDataStream &, const QRect &);
+ QDataStream &operator>>(QDataStream &, QRect &);
+inline QRect::QRect(int aleft, int atop, int awidth, int aheight)
+{
+    x1 = aleft;
+    y1 = atop;
+    x2 = (aleft + awidth - 1);
+    y2 = (atop + aheight - 1);
+}
+inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight)
+{
+    x1 = atopLeft.x();
+    y1 = atopLeft.y();
+    x2 = abottomRight.x();
+    y2 = abottomRight.y();
+}
+inline QRect::QRect(const QPoint &atopLeft, const QSize &asize)
+{
+    x1 = atopLeft.x();
+    y1 = atopLeft.y();
+    x2 = (x1+asize.width() - 1);
+    y2 = (y1+asize.height() - 1);
+}
+inline bool QRect::isNull() const
+{ return x2 == x1 - 1 && y2 == y1 - 1; }
+inline bool QRect::isEmpty() const
+{ return x1 > x2 || y1 > y2; }
+inline bool QRect::isValid() const
+{ return x1 <= x2 && y1 <= y2; }
+inline int QRect::left() const
+{ return x1; }
+inline int QRect::top() const
+{ return y1; }
+inline int QRect::right() const
+{ return x2; }
+inline int QRect::bottom() const
+{ return y2; }
+inline int QRect::x() const
+{ return x1; }
+inline int QRect::y() const
+{ return y1; }
+inline void QRect::setLeft(int pos)
+{ x1 = pos; }
+inline void QRect::setTop(int pos)
+{ y1 = pos; }
+inline void QRect::setRight(int pos)
+{ x2 = pos; }
+inline void QRect::setBottom(int pos)
+{ y2 = pos; }
+inline void QRect::setTopLeft(const QPoint &p)
+{ x1 = p.x(); y1 = p.y(); }
+inline void QRect::setBottomRight(const QPoint &p)
+{ x2 = p.x(); y2 = p.y(); }
+inline void QRect::setTopRight(const QPoint &p)
+{ x2 = p.x(); y1 = p.y(); }
+inline void QRect::setBottomLeft(const QPoint &p)
+{ x1 = p.x(); y2 = p.y(); }
+inline void QRect::setX(int ax)
+{ x1 = ax; }
+inline void QRect::setY(int ay)
+{ y1 = ay; }
+inline QPoint QRect::topLeft() const
+{ return QPoint(x1, y1); }
+inline QPoint QRect::bottomRight() const
+{ return QPoint(x2, y2); }
+inline QPoint QRect::topRight() const
+{ return QPoint(x2, y1); }
+inline QPoint QRect::bottomLeft() const
+{ return QPoint(x1, y2); }
+inline QPoint QRect::center() const
+{ return QPoint((x1+x2)/2, (y1+y2)/2); }
+inline int QRect::width() const
+{ return x2 - x1 + 1; }
+inline int QRect::height() const
+{ return y2 - y1 + 1; }
+inline QSize QRect::size() const
+{ return QSize(width(), height()); }
+inline void QRect::translate(int dx, int dy)
+{
+    x1 += dx;
+    y1 += dy;
+    x2 += dx;
+    y2 += dy;
+}
+inline void QRect::translate(const QPoint &p)
+{
+    x1 += p.x();
+    y1 += p.y();
+    x2 += p.x();
+    y2 += p.y();
+}
+inline QRect QRect::translated(int dx, int dy) const
+{ return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); }
+inline QRect QRect::translated(const QPoint &p) const
+{ return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }
+inline void QRect::moveTo(int ax, int ay)
+{
+    x2 += ax - x1;
+    y2 += ay - y1;
+    x1 = ax;
+    y1 = ay;
+}
+inline void QRect::moveTo(const QPoint &p)
+{
+    x2 += p.x() - x1;
+    y2 += p.y() - y1;
+    x1 = p.x();
+    y1 = p.y();
+}
+inline void QRect::moveLeft(int pos)
+{ x2 += (pos - x1); x1 = pos; }
+inline void QRect::moveTop(int pos)
+{ y2 += (pos - y1); y1 = pos; }
+inline void QRect::moveRight(int pos)
+{
+    x1 += (pos - x2);
+    x2 = pos;
+}
+inline void QRect::moveBottom(int pos)
+{
+    y1 += (pos - y2);
+    y2 = pos;
+}
+inline void QRect::moveTopLeft(const QPoint &p)
+{
+    moveLeft(p.x());
+    moveTop(p.y());
+}
+inline void QRect::moveBottomRight(const QPoint &p)
+{
+    moveRight(p.x());
+    moveBottom(p.y());
+}
+inline void QRect::moveTopRight(const QPoint &p)
+{
+    moveRight(p.x());
+    moveTop(p.y());
+}
+inline void QRect::moveBottomLeft(const QPoint &p)
+{
+    moveLeft(p.x());
+    moveBottom(p.y());
+}
+inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const
+{
+    *ax = x1;
+    *ay = y1;
+    *aw = x2 - x1 + 1;
+    *ah = y2 - y1 + 1;
+}
+inline void QRect::setRect(int ax, int ay, int aw, int ah)
+{
+    x1 = ax;
+    y1 = ay;
+    x2 = (ax + aw - 1);
+    y2 = (ay + ah - 1);
+}
+inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const
+{
+    *xp1 = x1;
+    *yp1 = y1;
+    *xp2 = x2;
+    *yp2 = y2;
+}
+inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2)
+{
+    x1 = xp1;
+    y1 = yp1;
+    x2 = xp2;
+    y2 = yp2;
+}
+inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const
+{ return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); }
+inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2)
+{
+    x1 += dx1;
+    y1 += dy1;
+    x2 += dx2;
+    y2 += dy2;
+}
+inline void QRect::setWidth(int w)
+{ x2 = (x1 + w - 1); }
+inline void QRect::setHeight(int h)
+{ y2 = (y1 + h - 1); }
+inline void QRect::setSize(const QSize &s)
+{
+    x2 = (s.width() + x1 - 1);
+    y2 = (s.height() + y1 - 1);
+}
+inline bool QRect::contains(int ax, int ay, bool aproper) const
+{
+    return contains(QPoint(ax, ay), aproper);
+}
+inline bool QRect::contains(int ax, int ay) const
+{
+    return contains(QPoint(ax, ay), false);
+}
+inline QRect& QRect::operator|=(const QRect &r)
+{
+    *this = *this | r;
+    return *this;
+}
+inline QRect& QRect::operator&=(const QRect &r)
+{
+    *this = *this & r;
+    return *this;
+}
+inline QRect QRect::intersect(const QRect &r) const
+{
+    return *this & r;
+}
+inline QRect QRect::intersected(const QRect &other) const
+{
+    return intersect(other);
+}
+inline QRect QRect::unite(const QRect &r) const
+{
+    return *this | r;
+}
+inline QRect QRect::united(const QRect &r) const
+{
+     return unite(r);
+}
+inline bool operator==(const QRect &r1, const QRect &r2)
+{
+    return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2;
+}
+inline bool operator!=(const QRect &r1, const QRect &r2)
+{
+    return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2;
+}
+ QDebug operator<<(QDebug, const QRect &);
+class QRectF
+{
+public:
+    QRectF() { xp = yp = 0.; w = h = 0.; }
+    QRectF(const QPointF &topleft, const QSizeF &size);
+    QRectF(const QPointF &topleft, const QPointF &bottomRight);
+    QRectF(qreal left, qreal top, qreal width, qreal height);
+    QRectF(const QRect &rect);
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+    QRectF normalized() const;
+    inline qreal left() const { return xp; }
+    inline qreal top() const { return yp; }
+    inline qreal right() const { return xp + w; }
+    inline qreal bottom() const { return yp + h; }
+    inline qreal x() const;
+    inline qreal y() const;
+    inline void setLeft(qreal pos);
+    inline void setTop(qreal pos);
+    inline void setRight(qreal pos);
+    inline void setBottom(qreal pos);
+    inline void setX(qreal pos) { setLeft(pos); }
+    inline void setY(qreal pos) { setTop(pos); }
+    inline QPointF topLeft() const { return QPointF(xp, yp); }
+    inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); }
+    inline QPointF topRight() const { return QPointF(xp+w, yp); }
+    inline QPointF bottomLeft() const { return QPointF(xp, yp+h); }
+    inline QPointF center() const;
+    void setTopLeft(const QPointF &p);
+    void setBottomRight(const QPointF &p);
+    void setTopRight(const QPointF &p);
+    void setBottomLeft(const QPointF &p);
+    void moveLeft(qreal pos);
+    void moveTop(qreal pos);
+    void moveRight(qreal pos);
+    void moveBottom(qreal pos);
+    void moveTopLeft(const QPointF &p);
+    void moveBottomRight(const QPointF &p);
+    void moveTopRight(const QPointF &p);
+    void moveBottomLeft(const QPointF &p);
+    void moveCenter(const QPointF &p);
+    void translate(qreal dx, qreal dy);
+    void translate(const QPointF &p);
+    QRectF translated(qreal dx, qreal dy) const;
+    QRectF translated(const QPointF &p) const;
+    void moveTo(qreal x, qreal t);
+    void moveTo(const QPointF &p);
+    void setRect(qreal x, qreal y, qreal w, qreal h);
+    void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const;
+    void setCoords(qreal x1, qreal y1, qreal x2, qreal y2);
+    void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const;
+    inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2);
+    inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const;
+    QSizeF size() const;
+    qreal width() const;
+    qreal height() const;
+    void setWidth(qreal w);
+    void setHeight(qreal h);
+    void setSize(const QSizeF &s);
+    QRectF operator|(const QRectF &r) const;
+    QRectF operator&(const QRectF &r) const;
+    QRectF& operator|=(const QRectF &r);
+    QRectF& operator&=(const QRectF &r);
+    bool contains(const QPointF &p) const;
+    bool contains(qreal x, qreal y) const;
+    bool contains(const QRectF &r) const;
+    QRectF unite(const QRectF &r) const;
+    QRectF united(const QRectF &other) const;
+    QRectF intersect(const QRectF &r) const;
+    QRectF intersected(const QRectF &other) const;
+    bool intersects(const QRectF &r) const;
+    friend inline bool operator==(const QRectF &, const QRectF &);
+    friend inline bool operator!=(const QRectF &, const QRectF &);
+    QRect toRect() const;
+    QRect toAlignedRect() const;
+private:
+    qreal xp;
+    qreal yp;
+    qreal w;
+    qreal h;
+};
+template<> class QTypeInfo<QRectF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRectF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRectF"; } };
+ inline bool operator==(const QRectF &, const QRectF &);
+ inline bool operator!=(const QRectF &, const QRectF &);
+ QDataStream &operator<<(QDataStream &, const QRectF &);
+ QDataStream &operator>>(QDataStream &, QRectF &);
+inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight)
+    : xp(aleft), yp(atop), w(awidth), h(aheight)
+{
+}
+inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize)
+{
+    xp = atopLeft.x();
+    yp = atopLeft.y();
+    w = asize.width();
+    h = asize.height();
+}
+inline QRectF::QRectF(const QPointF &atopLeft, const QPointF &abottomRight)
+{
+    xp = atopLeft.x();
+    yp = atopLeft.y();
+    w = abottomRight.x() - xp;
+    h = abottomRight.y() - yp;
+}
+inline QRectF::QRectF(const QRect &r)
+    : xp(r.x()), yp(r.y()), w(r.width()), h(r.height())
+{
+}
+inline bool QRectF::isNull() const
+{ return w == 0. && h == 0.; }
+inline bool QRectF::isEmpty() const
+{ return w <= 0. || h <= 0.; }
+inline bool QRectF::isValid() const
+{ return w > 0. && h > 0.; }
+inline qreal QRectF::x() const
+{ return xp; }
+inline qreal QRectF::y() const
+{ return yp; }
+inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; }
+inline void QRectF::setRight(qreal pos) { w = pos - xp; }
+inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; }
+inline void QRectF::setBottom(qreal pos) { h = pos - yp; }
+inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); }
+inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); }
+inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); }
+inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); }
+inline QPointF QRectF::center() const
+{ return QPointF(xp + w/2, yp + h/2); }
+inline void QRectF::moveLeft(qreal pos) { xp = pos; }
+inline void QRectF::moveTop(qreal pos) { yp = pos; }
+inline void QRectF::moveRight(qreal pos) { xp = pos - w; }
+inline void QRectF::moveBottom(qreal pos) { yp = pos - h; }
+inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); }
+inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); }
+inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); }
+inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); }
+inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; }
+inline qreal QRectF::width() const
+{ return w; }
+inline qreal QRectF::height() const
+{ return h; }
+inline QSizeF QRectF::size() const
+{ return QSizeF(w, h); }
+inline void QRectF::translate(qreal dx, qreal dy)
+{
+    xp += dx;
+    yp += dy;
+}
+inline void QRectF::translate(const QPointF &p)
+{
+    xp += p.x();
+    yp += p.y();
+}
+inline void QRectF::moveTo(qreal ax, qreal ay)
+{
+    xp = ax;
+    yp = ay;
+}
+inline void QRectF::moveTo(const QPointF &p)
+{
+    xp = p.x();
+    yp = p.y();
+}
+inline QRectF QRectF::translated(qreal dx, qreal dy) const
+{ return QRectF(xp + dx, yp + dy, w, h); }
+inline QRectF QRectF::translated(const QPointF &p) const
+{ return QRectF(xp + p.x(), yp + p.y(), w, h); }
+inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const
+{
+    *ax = this->xp;
+    *ay = this->yp;
+    *aaw = this->w;
+    *aah = this->h;
+}
+inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah)
+{
+    this->xp = ax;
+    this->yp = ay;
+    this->w = aaw;
+    this->h = aah;
+}
+inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const
+{
+    *xp1 = xp;
+    *yp1 = yp;
+    *xp2 = xp + w;
+    *yp2 = yp + h;
+}
+inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+{
+    xp = xp1;
+    yp = yp1;
+    w = xp2 - xp1;
+    h = yp2 - yp1;
+}
+inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+{ xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; }
+inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const
+{ return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); }
+inline void QRectF::setWidth(qreal aw)
+{ this->w = aw; }
+inline void QRectF::setHeight(qreal ah)
+{ this->h = ah; }
+inline void QRectF::setSize(const QSizeF &s)
+{
+    w = s.width();
+    h = s.height();
+}
+inline bool QRectF::contains(qreal ax, qreal ay) const
+{
+    return contains(QPointF(ax, ay));
+}
+inline QRectF& QRectF::operator|=(const QRectF &r)
+{
+    *this = *this | r;
+    return *this;
+}
+inline QRectF& QRectF::operator&=(const QRectF &r)
+{
+    *this = *this & r;
+    return *this;
+}
+inline QRectF QRectF::intersect(const QRectF &r) const
+{
+    return *this & r;
+}
+inline QRectF QRectF::intersected(const QRectF &r) const
+{
+    return intersect(r);
+}
+inline QRectF QRectF::unite(const QRectF &r) const
+{
+    return *this | r;
+}
+inline QRectF QRectF::united(const QRectF &r) const
+{
+    return unite(r);
+}
+inline bool operator==(const QRectF &r1, const QRectF &r2)
+{
+    return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp)
+           && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h);
+}
+inline bool operator!=(const QRectF &r1, const QRectF &r2)
+{
+    return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp)
+           || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h);
+}
+inline QRect QRectF::toRect() const
+{
+    return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h));
+}
+ QDebug operator<<(QDebug, const QRectF &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T>
+class QScopedValueRollback
+{
+public:
+    QScopedValueRollback(T &var) :
+        varRef(var)
+    {
+        oldValue = varRef;
+    }
+    ~QScopedValueRollback()
+    {
+        varRef = oldValue;
+    }
+    void commit()
+    {
+        oldValue = varRef;
+    }
+private:
+    T& varRef;
+    T oldValue;
+    QScopedValueRollback(const QScopedValueRollback &); QScopedValueRollback &operator=(const QScopedValueRollback &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T>
+class QSet
+{
+    typedef QHash<T, QHashDummyValue> Hash;
+public:
+    inline QSet() {}
+    inline QSet(const QSet<T> &other) : q_hash(other.q_hash) {}
+    inline QSet<T> &operator=(const QSet<T> &other)
+        { q_hash = other.q_hash; return *this; }
+    inline void swap(QSet<T> &other) { q_hash.swap(other.q_hash); }
+    inline bool operator==(const QSet<T> &other) const
+        { return q_hash == other.q_hash; }
+    inline bool operator!=(const QSet<T> &other) const
+        { return q_hash != other.q_hash; }
+    inline int size() const { return q_hash.size(); }
+    inline bool isEmpty() const { return q_hash.isEmpty(); }
+    inline int capacity() const { return q_hash.capacity(); }
+    inline void reserve(int size);
+    inline void squeeze() { q_hash.squeeze(); }
+    inline void detach() { q_hash.detach(); }
+    inline bool isDetached() const { return q_hash.isDetached(); }
+    inline void setSharable(bool sharable) { q_hash.setSharable(sharable); }
+    inline void clear() { q_hash.clear(); }
+    inline bool remove(const T &value) { return q_hash.remove(value) != 0; }
+    inline bool contains(const T &value) const { return q_hash.contains(value); }
+    bool contains(const QSet<T> &set) const;
+    class const_iterator;
+    class iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::iterator i;
+        friend class const_iterator;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline iterator() {}
+        inline iterator(typename Hash::iterator o) : i(o) {}
+        inline iterator(const iterator &o) : i(o.i) {}
+        inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { iterator r = *this; ++i; return r; }
+        inline iterator &operator--() { --i; return *this; }
+        inline iterator operator--(int) { iterator r = *this; --i; return r; }
+        inline iterator operator+(int j) const { return i + j; }
+        inline iterator operator-(int j) const { return i - j; }
+        inline iterator &operator+=(int j) { i += j; return *this; }
+        inline iterator &operator-=(int j) { i -= j; return *this; }
+    };
+    class const_iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::const_iterator i;
+        friend class iterator;
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline const_iterator() {}
+        inline const_iterator(typename Hash::const_iterator o) : i(o) {}
+        inline const_iterator(const const_iterator &o) : i(o.i) {}
+        inline const_iterator(const iterator &o)
+            : i(o.i) {}
+        inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() { ++i; return *this; }
+        inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; }
+        inline const_iterator &operator--() { --i; return *this; }
+        inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; }
+        inline const_iterator operator+(int j) const { return i + j; }
+        inline const_iterator operator-(int j) const { return i - j; }
+        inline const_iterator &operator+=(int j) { i += j; return *this; }
+        inline const_iterator &operator-=(int j) { i -= j; return *this; }
+    };
+    inline iterator begin() { return q_hash.begin(); }
+    inline const_iterator begin() const { return q_hash.begin(); }
+    inline const_iterator constBegin() const { return q_hash.constBegin(); }
+    inline iterator end() { return q_hash.end(); }
+    inline const_iterator end() const { return q_hash.end(); }
+    inline const_iterator constEnd() const { return q_hash.constEnd(); }
+    iterator erase(iterator i)
+        { return q_hash.erase(reinterpret_cast<typename Hash::iterator &>(i)); }
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return q_hash.count(); }
+    inline const_iterator insert(const T &value)
+        { return static_cast<typename Hash::const_iterator>(q_hash.insert(value,
+                                                                          QHashDummyValue())); }
+    iterator find(const T &value) { return q_hash.find(value); }
+    const_iterator find(const T &value) const { return q_hash.find(value); }
+    inline const_iterator constFind(const T &value) const { return find(value); }
+    QSet<T> &unite(const QSet<T> &other);
+    QSet<T> &intersect(const QSet<T> &other);
+    QSet<T> &subtract(const QSet<T> &other);
+    typedef T key_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+    inline bool empty() const { return isEmpty(); }
+    inline QSet<T> &operator<<(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator|=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; }
+    inline QSet<T> &operator&=(const T &value)
+        { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); }
+    inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator+=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; }
+    inline QSet<T> &operator-=(const T &value) { remove(value); return *this; }
+    inline QSet<T> operator|(const QSet<T> &other) const
+        { QSet<T> result = *this; result |= other; return result; }
+    inline QSet<T> operator&(const QSet<T> &other) const
+        { QSet<T> result = *this; result &= other; return result; }
+    inline QSet<T> operator+(const QSet<T> &other) const
+        { QSet<T> result = *this; result += other; return result; }
+    inline QSet<T> operator-(const QSet<T> &other) const
+        { QSet<T> result = *this; result -= other; return result; }
+    inline QSet<T> operator|(const QSet<T> &other)
+        { QSet<T> result = *this; result |= other; return result; }
+    inline QSet<T> operator&(const QSet<T> &other)
+        { QSet<T> result = *this; result &= other; return result; }
+    inline QSet<T> operator+(const QSet<T> &other)
+        { QSet<T> result = *this; result += other; return result; }
+    inline QSet<T> operator-(const QSet<T> &other)
+        { QSet<T> result = *this; result -= other; return result; }
+    QList<T> toList() const;
+    inline QList<T> values() const { return toList(); }
+    static QSet<T> fromList(const QList<T> &list);
+private:
+    Hash q_hash;
+};
+template <class T>
+inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); }
+template <class T>
+inline QSet<T> &QSet<T>::unite(const QSet<T> &other)
+{
+    QSet<T> copy(other);
+    typename QSet<T>::const_iterator i = copy.constEnd();
+    while (i != copy.constBegin()) {
+        --i;
+        insert(*i);
+    }
+    return *this;
+}
+template <class T>
+inline QSet<T> &QSet<T>::intersect(const QSet<T> &other)
+{
+    QSet<T> copy1(*this);
+    QSet<T> copy2(other);
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (!copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+template <class T>
+inline QSet<T> &QSet<T>::subtract(const QSet<T> &other)
+{
+    QSet<T> copy1(*this);
+    QSet<T> copy2(other);
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+template <class T>
+inline bool QSet<T>::contains(const QSet<T> &other) const
+{
+    typename QSet<T>::const_iterator i = other.constBegin();
+    while (i != other.constEnd()) {
+        if (!contains(*i))
+            return false;
+        ++i;
+    }
+    return true;
+}
+template <typename T>
+ QList<T> QSet<T>::toList() const
+{
+    QList<T> result;
+    result.reserve(size());
+    typename QSet<T>::const_iterator i = constBegin();
+    while (i != constEnd()) {
+        result.append(*i);
+        ++i;
+    }
+    return result;
+}
+template <typename T>
+ QSet<T> QList<T>::toSet() const
+{
+    QSet<T> result;
+    result.reserve(size());
+    for (int i = 0; i < size(); ++i)
+        result.insert(at(i));
+    return result;
+}
+template <typename T>
+QSet<T> QSet<T>::fromList(const QList<T> &list)
+{
+    return list.toSet();
+}
+template <typename T>
+QList<T> QList<T>::fromSet(const QSet<T> &set)
+{
+    return set.toList();
+}
+template <class T> class QSetIterator { typedef typename QSet<T>::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <typename T>
+class QMutableSetIterator
+{
+    typedef typename QSet<T>::iterator iterator;
+    QSet<T> *c;
+    iterator i, n;
+    inline bool item_exists() const { return c->constEnd() != n; }
+public:
+    inline QMutableSetIterator(QSet<T> &container)
+        : c(&container)
+    { c->setSharable(false); i = c->begin(); n = c->end(); }
+    inline ~QMutableSetIterator()
+    { c->setSharable(true); }
+    inline QMutableSetIterator &operator=(QSet<T> &container)
+    { c->setSharable(true); c = &container; c->setSharable(false);
+      i = c->begin(); n = c->end(); return *this; }
+    inline void toFront() { i = c->begin(); n = c->end(); }
+    inline void toBack() { i = c->end(); n = i; }
+    inline bool hasNext() const { return c->constEnd() != i; }
+    inline const T &next() { n = i++; return *n; }
+    inline const T &peekNext() const { return *i; }
+    inline bool hasPrevious() const { return c->constBegin() != i; }
+    inline const T &previous() { n = --i; return *n; }
+    inline const T &peekPrevious() const { iterator p = i; return *--p; }
+    inline void remove()
+    { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } }
+    inline const T &value() const { qt_noop(); return *n; }
+    inline bool findNext(const T &t)
+    { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; }
+    inline bool findPrevious(const T &t)
+    { while (c->constBegin() != i) if (*(n = --i) == t) return true;
+      n = c->end(); return false; }
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QVectorData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int size;
+    uint sharable : 1;
+    uint capacity : 1;
+    uint reserved : 30;
+    static QVectorData shared_null;
+    static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init);
+    static QVectorData *allocate(int size, int alignment);
+    static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment);
+    static void free(QVectorData *data, int alignment);
+    static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive);
+};
+template <typename T>
+struct QVectorTypedData : private QVectorData
+{
+    T array[1];
+    static inline void free(QVectorTypedData<T> *x, int alignment) { QVectorData::free(static_cast<QVectorData *>(x), alignment); }
+};
+class QRegion;
+template <typename T>
+class QVector
+{
+    typedef QVectorTypedData<T> Data;
+    union {
+        QVectorData *d;
+        Data *p;
+    };
+public:
+    inline QVector() : d(&QVectorData::shared_null) { d->ref.ref(); }
+    explicit QVector(int size);
+    QVector(int size, const T &t);
+    inline QVector(const QVector<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+    inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(p); }
+    QVector<T> &operator=(const QVector<T> &v);
+    inline void swap(QVector<T> &other) { qSwap(d, other.d); }
+    bool operator==(const QVector<T> &v) const;
+    inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }
+    inline int size() const { return d->size; }
+    inline bool isEmpty() const { return d->size == 0; }
+    void resize(int size);
+    inline int capacity() const { return d->alloc; }
+    void reserve(int size);
+    inline void squeeze() { realloc(d->size, d->size); d->capacity = 0; }
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline bool isSharedWith(const QVector<T> &other) const { return d == other.d; }
+    inline T *data() { detach(); return p->array; }
+    inline const T *data() const { return p->array; }
+    inline const T *constData() const { return p->array; }
+    void clear();
+    const T &at(int i) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+    void append(const T &t);
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void insert(int i, int n, const T &t);
+    void replace(int i, const T &t);
+    void remove(int i);
+    void remove(int i, int n);
+    QVector<T> &fill(const T &t, int size = -1);
+    int indexOf(const T &t, int from = 0) const;
+    int lastIndexOf(const T &t, int from = -1) const;
+    bool contains(const T &t) const;
+    int count(const T &t) const;
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    inline iterator begin() { detach(); return p->array; }
+    inline const_iterator begin() const { return p->array; }
+    inline const_iterator constBegin() const { return p->array; }
+    inline iterator end() { detach(); return p->array + d->size; }
+    inline const_iterator end() const { return p->array + d->size; }
+    inline const_iterator constEnd() const { return p->array + d->size; }
+    iterator insert(iterator before, int n, const T &x);
+    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
+    iterator erase(iterator begin, iterator end);
+    inline iterator erase(iterator pos) { return erase(pos, pos+1); }
+    inline int count() const { return d->size; }
+    inline T& first() { qt_noop(); return *begin(); }
+    inline const T &first() const { qt_noop(); return *begin(); }
+    inline T& last() { qt_noop(); return *(end()-1); }
+    inline const T &last() const { qt_noop(); return *(end()-1); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    QVector<T> mid(int pos, int length = -1) const;
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef qptrdiff difference_type;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef int size_type;
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    void pop_back() { qt_noop(); erase(end()-1); }
+    void pop_front() { qt_noop(); erase(begin()); }
+    inline bool empty() const
+    { return d->size == 0; }
+    inline T& front() { return first(); }
+    inline const_reference front() const { return first(); }
+    inline reference back() { return last(); }
+    inline const_reference back() const { return last(); }
+    QVector<T> &operator+=(const QVector<T> &l);
+    inline QVector<T> operator+(const QVector<T> &l) const
+    { QVector n = *this; n += l; return n; }
+    inline QVector<T> &operator+=(const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<< (const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<<(const QVector<T> &l)
+    { *this += l; return *this; }
+    QList<T> toList() const;
+    static QVector<T> fromList(const QList<T> &list);
+    static inline QVector<T> fromStdVector(const std::vector<T> &vector)
+    { QVector<T> tmp; tmp.reserve(int(vector.size())); qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::vector<T> toStdVector() const
+    { std::vector<T> tmp; tmp.reserve(size()); qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
+private:
+    friend class QRegion;
+    void detach_helper();
+    QVectorData *malloc(int alloc);
+    void realloc(int size, int alloc);
+    void free(Data *d);
+    int sizeOfTypedData() {
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+    inline int alignOfTypedData() const
+    {
+        return qMax<int>(sizeof(void*), __alignof__(Data));
+    }
+};
+template <typename T>
+void QVector<T>::detach_helper()
+{ realloc(d->size, d->alloc); }
+template <typename T>
+void QVector<T>::reserve(int asize)
+{ if (asize > d->alloc) realloc(d->size, asize); if (d->ref == 1) d->capacity = 1; }
+template <typename T>
+void QVector<T>::resize(int asize)
+{ realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ?
+          QVectorData::grow(sizeOfTypedData(), asize, sizeof(T), QTypeInfo<T>::isStatic)
+          : d->alloc); }
+template <typename T>
+inline void QVector<T>::clear()
+{ *this = QVector<T>(); }
+template <typename T>
+inline const T &QVector<T>::at(int i) const
+{ qt_noop();
+  return p->array[i]; }
+template <typename T>
+inline const T &QVector<T>::operator[](int i) const
+{ qt_noop();
+  return p->array[i]; }
+template <typename T>
+inline T &QVector<T>::operator[](int i)
+{ qt_noop();
+  return data()[i]; }
+template <typename T>
+inline void QVector<T>::insert(int i, const T &t)
+{ qt_noop();
+  insert(begin() + i, 1, t); }
+template <typename T>
+inline void QVector<T>::insert(int i, int n, const T &t)
+{ qt_noop();
+  insert(begin() + i, n, t); }
+template <typename T>
+inline void QVector<T>::remove(int i, int n)
+{ qt_noop();
+  erase(begin() + i, begin() + i + n); }
+template <typename T>
+inline void QVector<T>::remove(int i)
+{ qt_noop();
+  erase(begin() + i, begin() + i + 1); }
+template <typename T>
+inline void QVector<T>::prepend(const T &t)
+{ insert(begin(), 1, t); }
+template <typename T>
+inline void QVector<T>::replace(int i, const T &t)
+{
+    qt_noop();
+    const T copy(t);
+    data()[i] = copy;
+}
+template <typename T>
+QVector<T> &QVector<T>::operator=(const QVector<T> &v)
+{
+    QVectorData *o = v.d;
+    o->ref.ref();
+    if (!d->ref.deref())
+        free(p);
+    d = o;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+template <typename T>
+inline QVectorData *QVector<T>::malloc(int aalloc)
+{
+    QVectorData *vectordata = QVectorData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
+    do { if (!(vectordata)) qBadAlloc(); } while (0);
+    return vectordata;
+}
+template <typename T>
+QVector<T>::QVector(int asize)
+{
+    d = malloc(asize);
+    d->ref = 1;
+    d->alloc = d->size = asize;
+    d->sharable = true;
+    d->capacity = false;
+    if (QTypeInfo<T>::isComplex) {
+        T* b = p->array;
+        T* i = p->array + d->size;
+        while (i != b)
+            new (--i) T;
+    } else {
+        qMemSet(p->array, 0, asize * sizeof(T));
+    }
+}
+template <typename T>
+QVector<T>::QVector(int asize, const T &t)
+{
+    d = malloc(asize);
+    d->ref = 1;
+    d->alloc = d->size = asize;
+    d->sharable = true;
+    d->capacity = false;
+    T* i = p->array + d->size;
+    while (i != p->array)
+        new (--i) T(t);
+}
+template <typename T>
+void QVector<T>::free(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        T* b = x->array;
+        union { QVectorData *d; Data *p; } u;
+        u.p = x;
+        T* i = b + u.d->size;
+        while (i-- != b)
+             i->~T();
+    }
+    x->free(x, alignOfTypedData());
+}
+template <typename T>
+void QVector<T>::realloc(int asize, int aalloc)
+{
+    qt_noop();
+    T *pOld;
+    T *pNew;
+    union { QVectorData *d; Data *p; } x;
+    x.d = d;
+    if (QTypeInfo<T>::isComplex && asize < d->size && d->ref == 1 ) {
+        pOld = p->array + d->size;
+        pNew = p->array + asize;
+        while (asize < d->size) {
+            (--pOld)->~T();
+            d->size--;
+        }
+    }
+    if (aalloc != d->alloc || d->ref != 1) {
+        if (QTypeInfo<T>::isStatic) {
+            x.d = malloc(aalloc);
+            do { if (!(x.p)) qBadAlloc(); } while (0);
+            x.d->size = 0;
+        } else if (d->ref != 1) {
+            x.d = malloc(aalloc);
+            do { if (!(x.p)) qBadAlloc(); } while (0);
+            if (QTypeInfo<T>::isComplex) {
+                x.d->size = 0;
+            } else {
+                ::memcpy(x.p, p, sizeOfTypedData() + (qMin(aalloc, d->alloc) - 1) * sizeof(T));
+                x.d->size = d->size;
+            }
+        } else {
+            try {
+                QVectorData *mem = QVectorData::reallocate(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T),
+                                                           sizeOfTypedData() + (d->alloc - 1) * sizeof(T), alignOfTypedData());
+                do { if (!(mem)) qBadAlloc(); } while (0);
+                x.d = d = mem;
+                x.d->size = d->size;
+            } catch (const std::bad_alloc &) {
+                if (aalloc > d->alloc)
+                    throw;
+            }
+        }
+        x.d->ref = 1;
+        x.d->alloc = aalloc;
+        x.d->sharable = true;
+        x.d->capacity = d->capacity;
+        x.d->reserved = 0;
+    }
+    if (QTypeInfo<T>::isComplex) {
+        try {
+            pOld = p->array + x.d->size;
+            pNew = x.p->array + x.d->size;
+            const int toMove = qMin(asize, d->size);
+            while (x.d->size < toMove) {
+                new (pNew++) T(*pOld++);
+                x.d->size++;
+            }
+            while (x.d->size < asize) {
+                new (pNew++) T;
+                x.d->size++;
+            }
+        } catch (...) {
+            free(x.p);
+            throw;
+        }
+    } else if (asize > x.d->size) {
+        qMemSet(x.p->array + x.d->size, 0, (asize - x.d->size) * sizeof(T));
+    }
+    x.d->size = asize;
+    if (d != x.d) {
+        if (!d->ref.deref())
+            free(p);
+        d = x.d;
+    }
+}
+template<typename T>
+ T QVector<T>::value(int i) const
+{
+    if (i < 0 || i >= d->size) {
+        return T();
+    }
+    return p->array[i];
+}
+template<typename T>
+ T QVector<T>::value(int i, const T &defaultValue) const
+{
+    return ((i < 0 || i >= d->size) ? defaultValue : p->array[i]);
+}
+template <typename T>
+void QVector<T>::append(const T &t)
+{
+    if (d->ref != 1 || d->size + 1 > d->alloc) {
+        const T copy(t);
+        realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T),
+                                           QTypeInfo<T>::isStatic));
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->size) T(copy);
+        else
+            p->array[d->size] = copy;
+    } else {
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->size) T(t);
+        else
+            p->array[d->size] = t;
+    }
+    ++d->size;
+}
+template <typename T>
+typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
+{
+    int offset = int(before - p->array);
+    if (n != 0) {
+        const T copy(t);
+        if (d->ref != 1 || d->size + n > d->alloc)
+            realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T),
+                                               QTypeInfo<T>::isStatic));
+        if (QTypeInfo<T>::isStatic) {
+            T *b = p->array + d->size;
+            T *i = p->array + d->size + n;
+            while (i != b)
+                new (--i) T;
+            i = p->array + d->size;
+            T *j = i + n;
+            b = p->array + offset;
+            while (i != b)
+                *--j = *--i;
+            i = b+n;
+            while (i != b)
+                *--i = copy;
+        } else {
+            T *b = p->array + offset;
+            T *i = b + n;
+            memmove(i, b, (d->size - offset) * sizeof(T));
+            while (i != b)
+                new (--i) T(copy);
+        }
+        d->size += n;
+    }
+    return p->array + offset;
+}
+template <typename T>
+typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
+{
+    int f = int(abegin - p->array);
+    int l = int(aend - p->array);
+    int n = l - f;
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        qCopy(p->array+l, p->array+d->size, p->array+f);
+        T *i = p->array+d->size;
+        T* b = p->array+d->size-n;
+        while (i != b) {
+            --i;
+            i->~T();
+        }
+    } else {
+        memmove(p->array + f, p->array + l, (d->size-l)*sizeof(T));
+    }
+    d->size -= n;
+    return p->array + f;
+}
+template <typename T>
+bool QVector<T>::operator==(const QVector<T> &v) const
+{
+    if (d->size != v.d->size)
+        return false;
+    if (d == v.d)
+        return true;
+    T* b = p->array;
+    T* i = b + d->size;
+    T* j = v.p->array + d->size;
+    while (i != b)
+        if (!(*--i == *--j))
+            return false;
+    return true;
+}
+template <typename T>
+QVector<T> &QVector<T>::fill(const T &from, int asize)
+{
+    const T copy(from);
+    resize(asize < 0 ? d->size : asize);
+    if (d->size) {
+        T *i = p->array + d->size;
+        T *b = p->array;
+        while (i != b)
+            *--i = copy;
+    }
+    return *this;
+}
+template <typename T>
+QVector<T> &QVector<T>::operator+=(const QVector &l)
+{
+    int newSize = d->size + l.d->size;
+    realloc(d->size, newSize);
+    T *w = p->array + newSize;
+    T *i = l.p->array + l.d->size;
+    T *b = l.p->array;
+    while (i != b) {
+        if (QTypeInfo<T>::isComplex)
+            new (--w) T(*--i);
+        else
+            *--w = *--i;
+    }
+    d->size = newSize;
+    return *this;
+}
+template <typename T>
+int QVector<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + d->size, 0);
+    if (from < d->size) {
+        T* n = p->array + from - 1;
+        T* e = p->array + d->size;
+        while (++n != e)
+            if (*n == t)
+                return n - p->array;
+    }
+    return -1;
+}
+template <typename T>
+int QVector<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += d->size;
+    else if (from >= d->size)
+        from = d->size-1;
+    if (from >= 0) {
+        T* b = p->array;
+        T* n = p->array + from + 1;
+        while (n != b) {
+            if (*--n == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+template <typename T>
+bool QVector<T>::contains(const T &t) const
+{
+    T* b = p->array;
+    T* i = p->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            return true;
+    return false;
+}
+template <typename T>
+int QVector<T>::count(const T &t) const
+{
+    int c = 0;
+    T* b = p->array;
+    T* i = p->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            ++c;
+    return c;
+}
+template <typename T>
+ QVector<T> QVector<T>::mid(int pos, int length) const
+{
+    if (length < 0)
+        length = size() - pos;
+    if (pos == 0 && length == size())
+        return *this;
+    if (pos + length > size())
+        length = size() - pos;
+    QVector<T> copy;
+    copy.reserve(length);
+    for (int i = pos; i < pos + length; ++i)
+        copy += at(i);
+    return copy;
+}
+template <typename T>
+ QList<T> QVector<T>::toList() const
+{
+    QList<T> result;
+    result.reserve(size());
+    for (int i = 0; i < size(); ++i)
+        result.append(at(i));
+    return result;
+}
+template <typename T>
+ QVector<T> QList<T>::toVector() const
+{
+    QVector<T> result(size());
+    for (int i = 0; i < size(); ++i)
+        result[i] = at(i);
+    return result;
+}
+template <typename T>
+QVector<T> QVector<T>::fromList(const QList<T> &list)
+{
+    return list.toVector();
+}
+template <typename T>
+QList<T> QList<T>::fromVector(const QVector<T> &vector)
+{
+    return vector.toList();
+}
+template <class T> class QVectorIterator { typedef typename QVector<T>::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c.constBegin()) {} inline QVectorIterator &operator=(const QVector<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <class T> class QMutableVectorIterator { typedef typename QVector<T>::iterator iterator; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableVectorIterator() { c->setSharable(true); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template<class T>
+class QStack : public QVector<T>
+{
+public:
+    inline QStack() {}
+    inline ~QStack() {}
+    inline void swap(QStack<T> &other) { QVector<T>::swap(other); }
+    inline void push(const T &t) { QVector<T>::append(t); }
+    T pop();
+    T &top();
+    const T &top() const;
+};
+template<class T>
+inline T QStack<T>::pop()
+{ qt_noop(); T t = this->data()[this->size() -1];
+  this->resize(this->size()-1); return t; }
+template<class T>
+inline T &QStack<T>::top()
+{ qt_noop(); this->detach(); return this->data()[this->size()-1]; }
+template<class T>
+inline const T &QStack<T>::top() const
+{ qt_noop(); return this->data()[this->size()-1]; }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLatin1Literal
+{
+public:
+    int size() const { return m_size; }
+    const char *data() const { return m_data; }
+    template <int N>
+    QLatin1Literal(const char (&str)[N])
+        : m_size(N - 1), m_data(str) {}
+private:
+    const int m_size;
+    const char * const m_data;
+};
+struct QAbstractConcatenable
+{
+protected:
+    static void convertFromAscii(const char *a, int len, QChar *&out);
+    static void convertToAscii(const QChar *a, int len, char *&out);
+    static inline void convertFromAscii(char a, QChar *&out)
+    {
+        if (QString::codecForCStrings)
+            *out++ = QChar::fromAscii(a);
+        else
+            *out++ = QLatin1Char(a);
+    }
+    static inline void convertToAscii(QChar a, char *&out)
+    {
+        if (QString::codecForCStrings)
+            *out++ = a.toAscii();
+        else
+            convertToLatin1(a, out);
+    }
+    static inline void convertToLatin1(QChar a, char *&out)
+    {
+        *out++ = a.unicode() > 0xff ? '?' : char(a.unicode());
+    }
+};
+template <typename T> struct QConcatenable {};
+template <typename A, typename B>
+class QStringBuilder
+{
+public:
+    QStringBuilder(const A &a_, const B &b_) : a(a_), b(b_) {}
+private:
+    friend class QByteArray;
+    friend class QString;
+    template <typename T> T convertTo() const
+    {
+        const uint len = QConcatenable< QStringBuilder<A, B> >::size(*this);
+        T s(len, Qt::Uninitialized);
+        typename T::iterator d = s.data();
+        typename T::const_iterator const start = d;
+        QConcatenable< QStringBuilder<A, B> >::appendTo(*this, d);
+        if (!QConcatenable< QStringBuilder<A, B> >::ExactSize && int(len) != d - start) {
+            s.resize(d - start);
+        }
+        return s;
+    }
+    typedef QConcatenable<QStringBuilder<A, B> > Concatenable;
+    typedef typename Concatenable::ConvertTo ConvertTo;
+public:
+    operator ConvertTo() const { return convertTo<ConvertTo>(); }
+    QByteArray toLatin1() const { return convertTo<QString>().toLatin1(); }
+    int size() const { return Concatenable::size(*this); }
+    const A &a;
+    const B &b;
+};
+template <>
+class QStringBuilder <QString, QString>
+{
+    public:
+        QStringBuilder(const QString &a_, const QString &b_) : a(a_), b(b_) {}
+        operator QString() const
+        { QString r(a); r += b; return r; }
+        QByteArray toLatin1() const { return QString(*this).toLatin1(); }
+        const QString &a;
+        const QString &b;
+};
+template <>
+class QStringBuilder <QByteArray, QByteArray>
+{
+    public:
+        QStringBuilder(const QByteArray &a_, const QByteArray &b_) : a(a_), b(b_) {}
+        operator QByteArray() const
+        { QByteArray r(a); r += b; return r; }
+        const QByteArray &a;
+        const QByteArray &b;
+};
+template <> struct QConcatenable<char> : private QAbstractConcatenable
+{
+    typedef char type;
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = true };
+    static int size(const char) { return 1; }
+    static inline void appendTo(const char c, QChar *&out)
+    {
+        QAbstractConcatenable::convertFromAscii(c, out);
+    }
+    static inline void appendTo(const char c, char *&out)
+    { *out++ = c; }
+};
+template <> struct QConcatenable<QLatin1Char>
+{
+    typedef QLatin1Char type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QLatin1Char) { return 1; }
+    static inline void appendTo(const QLatin1Char c, QChar *&out)
+    { *out++ = c; }
+    static inline void appendTo(const QLatin1Char c, char *&out)
+    { *out++ = c.toLatin1(); }
+};
+template <> struct QConcatenable<QChar> : private QAbstractConcatenable
+{
+    typedef QChar type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QChar) { return 1; }
+    static inline void appendTo(const QChar c, QChar *&out)
+    { *out++ = c; }
+    static inline void appendTo(const QChar c, char *&out)
+    { convertToAscii(c, out); }
+};
+template <> struct QConcatenable<QCharRef> : private QAbstractConcatenable
+{
+    typedef QCharRef type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QCharRef &) { return 1; }
+    static inline void appendTo(const QCharRef &c, QChar *&out)
+    { *out++ = QChar(c); }
+    static inline void appendTo(const QCharRef &c, char *&out)
+    { convertToAscii(c, out); }
+};
+template <> struct QConcatenable<QLatin1String>
+{
+    typedef QLatin1String type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QLatin1String &a) { return qstrlen(a.latin1()); }
+    static inline void appendTo(const QLatin1String &a, QChar *&out)
+    {
+        for (const char *s = a.latin1(); *s; )
+            *out++ = QLatin1Char(*s++);
+    }
+    static inline void appendTo(const QLatin1String &a, char *&out)
+    {
+        for (const char *s = a.latin1(); *s; )
+            *out++ = *s++;
+    }
+};
+template <> struct QConcatenable<QLatin1Literal>
+{
+    typedef QLatin1Literal type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QLatin1Literal &a) { return a.size(); }
+    static inline void appendTo(const QLatin1Literal &a, QChar *&out)
+    {
+        for (const char *s = a.data(); *s; )
+            *out++ = QLatin1Char(*s++);
+    }
+    static inline void appendTo(const QLatin1Literal &a, char *&out)
+    {
+        for (const char *s = a.data(); *s; )
+            *out++ = *s++;
+    }
+};
+template <> struct QConcatenable<QString> : private QAbstractConcatenable
+{
+    typedef QString type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QString &a) { return a.size(); }
+    static inline void appendTo(const QString &a, QChar *&out)
+    {
+        const int n = a.size();
+        memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
+        out += n;
+    }
+    static inline void appendTo(const QString &a, char *&out)
+    { convertToAscii(a.constData(), a.length(), out); }
+};
+template <> struct QConcatenable<QStringRef> : private QAbstractConcatenable
+{
+    typedef QStringRef type;
+    typedef QString ConvertTo;
+    enum { ExactSize = true };
+    static int size(const QStringRef &a) { return a.size(); }
+    static inline void appendTo(const QStringRef &a, QChar *&out)
+    {
+        const int n = a.size();
+        memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
+        out += n;
+    }
+    static inline void appendTo(const QStringRef &a, char *&out)
+    { convertToAscii(a.constData(), a.length(), out); }
+};
+template <int N> struct QConcatenable<char[N]> : private QAbstractConcatenable
+{
+    typedef char type[N];
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = false };
+    static int size(const char[N]) { return N - 1; }
+    static inline void appendTo(const char a[N], QChar *&out)
+    {
+        QAbstractConcatenable::convertFromAscii(a, N, out);
+    }
+    static inline void appendTo(const char a[N], char *&out)
+    {
+        while (*a)
+            *out++ = *a++;
+    }
+};
+template <int N> struct QConcatenable<const char[N]> : private QAbstractConcatenable
+{
+    typedef const char type[N];
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = false };
+    static int size(const char[N]) { return N - 1; }
+    static inline void appendTo(const char a[N], QChar *&out)
+    {
+        QAbstractConcatenable::convertFromAscii(a, N, out);
+    }
+    static inline void appendTo(const char a[N], char *&out)
+    {
+        while (*a)
+            *out++ = *a++;
+    }
+};
+template <> struct QConcatenable<const char *> : private QAbstractConcatenable
+{
+    typedef char const *type;
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = false };
+    static int size(const char *a) { return qstrlen(a); }
+    static inline void appendTo(const char *a, QChar *&out)
+    { QAbstractConcatenable::convertFromAscii(a, -1, out); }
+    static inline void appendTo(const char *a, char *&out)
+    {
+        if (!a)
+            return;
+        while (*a)
+            *out++ = *a++;
+    }
+};
+template <> struct QConcatenable<QByteArray> : private QAbstractConcatenable
+{
+    typedef QByteArray type;
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = false };
+    static int size(const QByteArray &ba) { return ba.size(); }
+    static inline void appendTo(const QByteArray &ba, QChar *&out)
+    {
+        QAbstractConcatenable::convertFromAscii(ba.constData(), ba.size() + 1, out);
+    }
+    static inline void appendTo(const QByteArray &ba, char *&out)
+    {
+        const char *a = ba.constData();
+        const char * const end = ba.end();
+        while (a != end)
+            *out++ = *a++;
+    }
+};
+namespace QtStringBuilder {
+    template <typename A, typename B> struct ConvertToTypeHelper
+    { typedef A ConvertTo; };
+    template <typename T> struct ConvertToTypeHelper<T, QString>
+    { typedef QString ConvertTo; };
+}
+template <typename A, typename B>
+struct QConcatenable< QStringBuilder<A, B> >
+{
+    typedef QStringBuilder<A, B> type;
+    typedef typename QtStringBuilder::ConvertToTypeHelper<typename QConcatenable<A>::ConvertTo, typename QConcatenable<B>::ConvertTo>::ConvertTo ConvertTo;
+    enum { ExactSize = QConcatenable<A>::ExactSize && QConcatenable<B>::ExactSize };
+    static int size(const type &p)
+    {
+        return QConcatenable<A>::size(p.a) + QConcatenable<B>::size(p.b);
+    }
+    template<typename T> static inline void appendTo(const type &p, T *&out)
+    {
+        QConcatenable<A>::appendTo(p.a, out);
+        QConcatenable<B>::appendTo(p.b, out);
+    }
+};
+template <typename A, typename B>
+QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
+operator%(const A &a, const B &b)
+{
+   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
+}
+template <typename A, typename B>
+QByteArray &operator+=(QByteArray &a, const QStringBuilder<A, B> &b)
+{
+    if (sizeof(typename QConcatenable< QStringBuilder<A, B> >::ConvertTo::value_type) == sizeof(QChar)) {
+        return a += QString(b);
+    }
+    int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
+    a.reserve(len);
+    char *it = a.data() + a.size();
+    QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
+    a.resize(len);
+    return a;
+}
+template <typename A, typename B>
+QString &operator+=(QString &a, const QStringBuilder<A, B> &b)
+{
+    int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
+    a.reserve(len);
+    QChar *it = a.data() + a.size();
+    QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
+    a.resize(it - a.constData());
+    return a;
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTextBoundaryFinderPrivate;
+class QTextBoundaryFinder
+{
+public:
+    QTextBoundaryFinder();
+    QTextBoundaryFinder(const QTextBoundaryFinder &other);
+    QTextBoundaryFinder &operator=(const QTextBoundaryFinder &other);
+    ~QTextBoundaryFinder();
+    enum BoundaryType {
+        Grapheme,
+        Word,
+        Line,
+        Sentence
+    };
+    enum BoundaryReason {
+        NotAtBoundary = 0,
+        StartWord = 1,
+        EndWord = 2
+    };
+    typedef QFlags<BoundaryReason> BoundaryReasons;
+    QTextBoundaryFinder(BoundaryType type, const QString &string);
+    QTextBoundaryFinder(BoundaryType type, const QChar *chars, int length, unsigned char *buffer = 0, int bufferSize = 0);
+    inline bool isValid() const { return d; }
+    inline BoundaryType type() const { return t; }
+    QString string() const;
+    void toStart();
+    void toEnd();
+    int position() const;
+    void setPosition(int position);
+    int toNextBoundary();
+    int toPreviousBoundary();
+    bool isAtBoundary() const;
+    BoundaryReasons boundaryReasons() const;
+private:
+    BoundaryType t;
+    QString s;
+    const QChar *chars;
+    int length;
+    int pos;
+    uint freePrivate : 1;
+    uint unused : 31;
+    QTextBoundaryFinderPrivate *d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTimeLinePrivate;
+class QTimeLine : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum State {
+        NotRunning,
+        Paused,
+        Running
+    };
+    enum Direction {
+        Forward,
+        Backward
+    };
+    enum CurveShape {
+        EaseInCurve,
+        EaseOutCurve,
+        EaseInOutCurve,
+        LinearCurve,
+        SineCurve,
+        CosineCurve
+    };
+    explicit QTimeLine(int duration = 1000, QObject *parent = 0);
+    virtual ~QTimeLine();
+    State state() const;
+    int loopCount() const;
+    void setLoopCount(int count);
+    Direction direction() const;
+    void setDirection(Direction direction);
+    int duration() const;
+    void setDuration(int duration);
+    int startFrame() const;
+    void setStartFrame(int frame);
+    int endFrame() const;
+    void setEndFrame(int frame);
+    void setFrameRange(int startFrame, int endFrame);
+    int updateInterval() const;
+    void setUpdateInterval(int interval);
+    CurveShape curveShape() const;
+    void setCurveShape(CurveShape shape);
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &curve);
+    int currentTime() const;
+    int currentFrame() const;
+    qreal currentValue() const;
+    int frameForTime(int msec) const;
+    virtual qreal valueForTime(int msec) const;
+public :
+    void start();
+    void resume();
+    void stop();
+    void setPaused(bool paused);
+    void setCurrentTime(int msec);
+    void toggleDirection();
+protected:
+    void valueChanged(qreal x);
+    void frameChanged(int);
+    void stateChanged(QTimeLine::State newState);
+    void finished();
+protected:
+    void timerEvent(QTimerEvent *event);
+private:
+    QTimeLine(const QTimeLine &); QTimeLine &operator=(const QTimeLine &);
+    inline QTimeLinePrivate* d_func() { return reinterpret_cast<QTimeLinePrivate *>(qGetPtrHelper(d_ptr)); } inline const QTimeLinePrivate* d_func() const { return reinterpret_cast<const QTimeLinePrivate *>(qGetPtrHelper(d_ptr)); } friend class QTimeLinePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template<class T, int Prealloc>
+class QPodList;
+template<class T, int Prealloc>
+class QVarLengthArray
+{
+public:
+    inline explicit QVarLengthArray(int size = 0);
+    inline QVarLengthArray(const QVarLengthArray<T, Prealloc> &other)
+        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
+    {
+        append(other.constData(), other.size());
+    }
+    inline ~QVarLengthArray() {
+        if (QTypeInfo<T>::isComplex) {
+            T *i = ptr + s;
+            while (i-- != ptr)
+                i->~T();
+        }
+        if (ptr != reinterpret_cast<T *>(array))
+            qFree(ptr);
+    }
+    inline QVarLengthArray<T, Prealloc> &operator=(const QVarLengthArray<T, Prealloc> &other)
+    {
+        if (this != &other) {
+            clear();
+            append(other.constData(), other.size());
+        }
+        return *this;
+    }
+    inline void removeLast() {
+        qt_noop();
+        realloc(s - 1, a);
+    }
+    inline int size() const { return s; }
+    inline int count() const { return s; }
+    inline bool isEmpty() const { return (s == 0); }
+    inline void resize(int size);
+    inline void clear() { resize(0); }
+    inline int capacity() const { return a; }
+    inline void reserve(int size);
+    inline T &operator[](int idx) {
+        qt_noop();
+        return ptr[idx];
+    }
+    inline const T &operator[](int idx) const {
+        qt_noop();
+        return ptr[idx];
+    }
+    inline const T &at(int idx) const { return operator[](idx); }
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+    inline void append(const T &t) {
+        if (s == a)
+            realloc(s, s<<1);
+        const int idx = s++;
+        if (QTypeInfo<T>::isComplex) {
+            new (ptr + idx) T(t);
+        } else {
+            ptr[idx] = t;
+        }
+    }
+    void append(const T *buf, int size);
+    inline QVarLengthArray<T, Prealloc> &operator<<(const T &t)
+    { append(t); return *this; }
+    inline QVarLengthArray<T, Prealloc> &operator+=(const T &t)
+    { append(t); return *this; }
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void insert(int i, int n, const T &t);
+    void replace(int i, const T &t);
+    void remove(int i);
+    void remove(int i, int n);
+    inline T *data() { return ptr; }
+    inline const T *data() const { return ptr; }
+    inline const T * constData() const { return ptr; }
+    typedef int size_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    typedef T* iterator;
+    typedef const T* const_iterator;
+    inline iterator begin() { return ptr; }
+    inline const_iterator begin() const { return ptr; }
+    inline const_iterator constBegin() const { return ptr; }
+    inline iterator end() { return ptr + s; }
+    inline const_iterator end() const { return ptr + s; }
+    inline const_iterator constEnd() const { return ptr + s; }
+    iterator insert(iterator before, int n, const T &x);
+    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
+    iterator erase(iterator begin, iterator end);
+    inline iterator erase(iterator pos) { return erase(pos, pos+1); }
+private:
+    friend class QPodList<T, Prealloc>;
+    void realloc(int size, int alloc);
+    int a;
+    int s;
+    T *ptr;
+    union {
+        char array[sizeof(qint64) * (((Prealloc * sizeof(T)) / sizeof(qint64)) + 1)];
+        qint64 q_for_alignment_1;
+        double q_for_alignment_2;
+    };
+};
+template <class T, int Prealloc>
+inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize)
+    : s(asize) {
+    if (s > Prealloc) {
+        ptr = reinterpret_cast<T *>(qMalloc(s * sizeof(T)));
+        do { if (!(ptr)) qBadAlloc(); } while (0);
+        a = s;
+    } else {
+        ptr = reinterpret_cast<T *>(array);
+        a = Prealloc;
+    }
+    if (QTypeInfo<T>::isComplex) {
+        T *i = ptr + s;
+        while (i != ptr)
+            new (--i) T;
+    }
+}
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::resize(int asize)
+{ realloc(asize, qMax(asize, a)); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::reserve(int asize)
+{ if (asize > a) realloc(s, asize); }
+template <class T, int Prealloc>
+ void QVarLengthArray<T, Prealloc>::append(const T *abuf, int increment)
+{
+    qt_noop();
+    if (increment <= 0)
+        return;
+    const int asize = s + increment;
+    if (asize >= a)
+        realloc(s, qMax(s*2, asize));
+    if (QTypeInfo<T>::isComplex) {
+        while (s < asize)
+            new (ptr+(s++)) T(*abuf++);
+    } else {
+        qMemCopy(&ptr[s], abuf, increment * sizeof(T));
+        s = asize;
+    }
+}
+template <class T, int Prealloc>
+ void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
+{
+    qt_noop();
+    T *oldPtr = ptr;
+    int osize = s;
+    const int copySize = qMin(asize, osize);
+    if (aalloc != a) {
+        ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T)));
+        do { if (!(ptr)) qBadAlloc(); } while (0);
+        if (ptr) {
+            s = 0;
+            a = aalloc;
+            if (QTypeInfo<T>::isStatic) {
+                try {
+                    while (s < copySize) {
+                        new (ptr+s) T(*(oldPtr+s));
+                        (oldPtr+s)->~T();
+                        s++;
+                    }
+                } catch (...) {
+                    int sClean = s;
+                    while (sClean < osize)
+                        (oldPtr+(sClean++))->~T();
+                    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
+                        qFree(oldPtr);
+                    throw;
+                }
+            } else {
+                qMemCopy(ptr, oldPtr, copySize * sizeof(T));
+            }
+        } else {
+            ptr = oldPtr;
+            return;
+        }
+    }
+    s = copySize;
+    if (QTypeInfo<T>::isComplex) {
+        while (osize > asize)
+            (oldPtr+(--osize))->~T();
+    }
+    if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
+        qFree(oldPtr);
+    if (QTypeInfo<T>::isComplex) {
+        while (s < asize)
+            new (ptr+(s++)) T;
+    } else {
+        s = asize;
+    }
+}
+template <class T, int Prealloc>
+ T QVarLengthArray<T, Prealloc>::value(int i) const
+{
+    if (i < 0 || i >= size()) {
+        return T();
+    }
+    return at(i);
+}
+template <class T, int Prealloc>
+ T QVarLengthArray<T, Prealloc>::value(int i, const T &defaultValue) const
+{
+    return (i < 0 || i >= size()) ? defaultValue : at(i);
+}
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::insert(int i, const T &t)
+{ qt_noop();
+  insert(begin() + i, 1, t); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::insert(int i, int n, const T &t)
+{ qt_noop();
+  insert(begin() + i, n, t); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::remove(int i, int n)
+{ qt_noop();
+  erase(begin() + i, begin() + i + n); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::remove(int i)
+{ qt_noop();
+  erase(begin() + i, begin() + i + 1); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::prepend(const T &t)
+{ insert(begin(), 1, t); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::replace(int i, const T &t)
+{
+    qt_noop();
+    const T copy(t);
+    data()[i] = copy;
+}
+template <class T, int Prealloc>
+ typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::insert(iterator before, size_type n, const T &t)
+{
+    int offset = int(before - ptr);
+    if (n != 0) {
+        resize(s + n);
+        const T copy(t);
+        if (QTypeInfo<T>::isStatic) {
+            T *b = ptr + offset;
+            T *j = ptr + s;
+            T *i = j - n;
+            while (i != b)
+                *--j = *--i;
+            i = b + n;
+            while (i != b)
+                *--i = copy;
+        } else {
+            T *b = ptr + offset;
+            T *i = b + n;
+            memmove(i, b, (s - offset - n) * sizeof(T));
+            while (i != b)
+                new (--i) T(copy);
+        }
+    }
+    return ptr + offset;
+}
+template <class T, int Prealloc>
+ typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::erase(iterator abegin, iterator aend)
+{
+    int f = int(abegin - ptr);
+    int l = int(aend - ptr);
+    int n = l - f;
+    if (QTypeInfo<T>::isComplex) {
+        qCopy(ptr + l, ptr + s, ptr + f);
+        T *i = ptr + s;
+        T *b = ptr + s - n;
+        while (i != b) {
+            --i;
+            i->~T();
+        }
+    } else {
+        memmove(ptr + f, ptr + l, (s - l) * sizeof(T));
+    }
+    s -= n;
+    return ptr + f;
+}
+template <typename T, int Prealloc1, int Prealloc2>
+bool operator==(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
+{
+    if (l.size() != r.size())
+        return false;
+    for (int i = 0; i < l.size(); i++) {
+        if (l.at(i) != r.at(i))
+            return false;
+    }
+    return true;
+}
+template <typename T, int Prealloc1, int Prealloc2>
+bool operator!=(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
+{
+    return !(l == r);
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QXmlStreamStringRef {
+    QString m_string;
+    int m_position, m_size;
+public:
+    inline QXmlStreamStringRef():m_position(0), m_size(0){}
+    inline QXmlStreamStringRef(const QStringRef &aString)
+        :m_string(aString.string()?*aString.string():QString()), m_position(aString.position()), m_size(aString.size()){}
+    inline QXmlStreamStringRef(const QString &aString):m_string(aString), m_position(0), m_size(aString.size()){}
+    inline ~QXmlStreamStringRef(){}
+    inline void clear() { m_string.clear(); m_position = m_size = 0; }
+    inline operator QStringRef() const { return QStringRef(&m_string, m_position, m_size); }
+    inline const QString *string() const { return &m_string; }
+    inline int position() const { return m_position; }
+    inline int size() const { return m_size; }
+};
+class QXmlStreamReaderPrivate;
+class QXmlStreamAttributes;
+class QXmlStreamAttribute {
+    QXmlStreamStringRef m_name, m_namespaceUri, m_qualifiedName, m_value;
+    void *reserved;
+    uint m_isDefault : 1;
+    friend class QXmlStreamReaderPrivate;
+    friend class QXmlStreamAttributes;
+public:
+    QXmlStreamAttribute();
+    QXmlStreamAttribute(const QString &qualifiedName, const QString &value);
+    QXmlStreamAttribute(const QString &namespaceUri, const QString &name, const QString &value);
+    QXmlStreamAttribute(const QXmlStreamAttribute &);
+    QXmlStreamAttribute& operator=(const QXmlStreamAttribute &);
+    ~QXmlStreamAttribute();
+    inline QStringRef namespaceUri() const { return m_namespaceUri; }
+    inline QStringRef name() const { return m_name; }
+    inline QStringRef qualifiedName() const { return m_qualifiedName; }
+    inline QStringRef prefix() const {
+        return QStringRef(m_qualifiedName.string(),
+                          m_qualifiedName.position(),
+                          qMax(0, m_qualifiedName.size() - m_name.size() - 1));
+    }
+    inline QStringRef value() const { return m_value; }
+    inline bool isDefault() const { return m_isDefault; }
+    inline bool operator==(const QXmlStreamAttribute &other) const {
+        return (value() == other.value()
+                && (namespaceUri().isNull() ? (qualifiedName() == other.qualifiedName())
+                    : (namespaceUri() == other.namespaceUri() && name() == other.name())));
+    }
+    inline bool operator!=(const QXmlStreamAttribute &other) const
+        { return !operator==(other); }
+};
+template<> class QTypeInfo<QXmlStreamAttribute > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QXmlStreamAttribute)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QXmlStreamAttribute"; } };
+class QXmlStreamAttributes : public QVector<QXmlStreamAttribute>
+{
+public:
+    inline QXmlStreamAttributes() {}
+    QStringRef value(const QString &namespaceUri, const QString &name) const;
+    QStringRef value(const QString &namespaceUri, const QLatin1String &name) const;
+    QStringRef value(const QLatin1String &namespaceUri, const QLatin1String &name) const;
+    QStringRef value(const QString &qualifiedName) const;
+    QStringRef value(const QLatin1String &qualifiedName) const;
+    void append(const QString &namespaceUri, const QString &name, const QString &value);
+    void append(const QString &qualifiedName, const QString &value);
+    inline bool hasAttribute(const QString &qualifiedName) const
+    {
+        return !value(qualifiedName).isNull();
+    }
+    inline bool hasAttribute(const QLatin1String &qualifiedName) const
+    {
+        return !value(qualifiedName).isNull();
+    }
+    inline bool hasAttribute(const QString &namespaceUri, const QString &name) const
+    {
+        return !value(namespaceUri, name).isNull();
+    }
+    using QVector<QXmlStreamAttribute>::append;
+};
+class QXmlStreamNamespaceDeclaration {
+    QXmlStreamStringRef m_prefix, m_namespaceUri;
+    void *reserved;
+    friend class QXmlStreamReaderPrivate;
+public:
+    QXmlStreamNamespaceDeclaration();
+    QXmlStreamNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &);
+    QXmlStreamNamespaceDeclaration(const QString &prefix, const QString &namespaceUri);
+    ~QXmlStreamNamespaceDeclaration();
+    QXmlStreamNamespaceDeclaration& operator=(const QXmlStreamNamespaceDeclaration &);
+    inline QStringRef prefix() const { return m_prefix; }
+    inline QStringRef namespaceUri() const { return m_namespaceUri; }
+    inline bool operator==(const QXmlStreamNamespaceDeclaration &other) const {
+        return (prefix() == other.prefix() && namespaceUri() == other.namespaceUri());
+    }
+    inline bool operator!=(const QXmlStreamNamespaceDeclaration &other) const
+        { return !operator==(other); }
+};
+template<> class QTypeInfo<QXmlStreamNamespaceDeclaration > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QXmlStreamNamespaceDeclaration)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QXmlStreamNamespaceDeclaration"; } };
+typedef QVector<QXmlStreamNamespaceDeclaration> QXmlStreamNamespaceDeclarations;
+class QXmlStreamNotationDeclaration {
+    QXmlStreamStringRef m_name, m_systemId, m_publicId;
+    void *reserved;
+    friend class QXmlStreamReaderPrivate;
+public:
+    QXmlStreamNotationDeclaration();
+    ~QXmlStreamNotationDeclaration();
+    QXmlStreamNotationDeclaration(const QXmlStreamNotationDeclaration &);
+    QXmlStreamNotationDeclaration& operator=(const QXmlStreamNotationDeclaration &);
+    inline QStringRef name() const { return m_name; }
+    inline QStringRef systemId() const { return m_systemId; }
+    inline QStringRef publicId() const { return m_publicId; }
+    inline bool operator==(const QXmlStreamNotationDeclaration &other) const {
+        return (name() == other.name() && systemId() == other.systemId()
+                && publicId() == other.publicId());
+    }
+    inline bool operator!=(const QXmlStreamNotationDeclaration &other) const
+        { return !operator==(other); }
+};
+template<> class QTypeInfo<QXmlStreamNotationDeclaration > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QXmlStreamNotationDeclaration)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QXmlStreamNotationDeclaration"; } };
+typedef QVector<QXmlStreamNotationDeclaration> QXmlStreamNotationDeclarations;
+class QXmlStreamEntityDeclaration {
+    QXmlStreamStringRef m_name, m_notationName, m_systemId, m_publicId, m_value;
+    void *reserved;
+    friend class QXmlStreamReaderPrivate;
+public:
+    QXmlStreamEntityDeclaration();
+    ~QXmlStreamEntityDeclaration();
+    QXmlStreamEntityDeclaration(const QXmlStreamEntityDeclaration &);
+    QXmlStreamEntityDeclaration& operator=(const QXmlStreamEntityDeclaration &);
+    inline QStringRef name() const { return m_name; }
+    inline QStringRef notationName() const { return m_notationName; }
+    inline QStringRef systemId() const { return m_systemId; }
+    inline QStringRef publicId() const { return m_publicId; }
+    inline QStringRef value() const { return m_value; }
+    inline bool operator==(const QXmlStreamEntityDeclaration &other) const {
+        return (name() == other.name()
+                && notationName() == other.notationName()
+                && systemId() == other.systemId()
+                && publicId() == other.publicId()
+                && value() == other.value());
+    }
+    inline bool operator!=(const QXmlStreamEntityDeclaration &other) const
+        { return !operator==(other); }
+};
+template<> class QTypeInfo<QXmlStreamEntityDeclaration > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QXmlStreamEntityDeclaration)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QXmlStreamEntityDeclaration"; } };
+typedef QVector<QXmlStreamEntityDeclaration> QXmlStreamEntityDeclarations;
+class QXmlStreamEntityResolver
+{
+public:
+    virtual ~QXmlStreamEntityResolver();
+    virtual QString resolveEntity(const QString& publicId, const QString& systemId);
+    virtual QString resolveUndeclaredEntity(const QString &name);
+};
+class QXmlStreamReader {
+public:
+    enum TokenType {
+        NoToken = 0,
+        Invalid,
+        StartDocument,
+        EndDocument,
+        StartElement,
+        EndElement,
+        Characters,
+        Comment,
+        DTD,
+        EntityReference,
+        ProcessingInstruction
+    };
+    QXmlStreamReader();
+    QXmlStreamReader(QIODevice *device);
+    QXmlStreamReader(const QByteArray &data);
+    QXmlStreamReader(const QString &data);
+    QXmlStreamReader(const char * data);
+    ~QXmlStreamReader();
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+    void addData(const QByteArray &data);
+    void addData(const QString &data);
+    void addData(const char *data);
+    void clear();
+    bool atEnd() const;
+    TokenType readNext();
+    bool readNextStartElement();
+    void skipCurrentElement();
+    TokenType tokenType() const;
+    QString tokenString() const;
+    void setNamespaceProcessing(bool);
+    bool namespaceProcessing() const;
+    inline bool isStartDocument() const { return tokenType() == StartDocument; }
+    inline bool isEndDocument() const { return tokenType() == EndDocument; }
+    inline bool isStartElement() const { return tokenType() == StartElement; }
+    inline bool isEndElement() const { return tokenType() == EndElement; }
+    inline bool isCharacters() const { return tokenType() == Characters; }
+    bool isWhitespace() const;
+    bool isCDATA() const;
+    inline bool isComment() const { return tokenType() == Comment; }
+    inline bool isDTD() const { return tokenType() == DTD; }
+    inline bool isEntityReference() const { return tokenType() == EntityReference; }
+    inline bool isProcessingInstruction() const { return tokenType() == ProcessingInstruction; }
+    bool isStandaloneDocument() const;
+    QStringRef documentVersion() const;
+    QStringRef documentEncoding() const;
+    qint64 lineNumber() const;
+    qint64 columnNumber() const;
+    qint64 characterOffset() const;
+    QXmlStreamAttributes attributes() const;
+    enum ReadElementTextBehaviour {
+        ErrorOnUnexpectedElement,
+        IncludeChildElements,
+        SkipChildElements
+    };
+    QString readElementText(ReadElementTextBehaviour behaviour);
+    QString readElementText();
+    QStringRef name() const;
+    QStringRef namespaceUri() const;
+    QStringRef qualifiedName() const;
+    QStringRef prefix() const;
+    QStringRef processingInstructionTarget() const;
+    QStringRef processingInstructionData() const;
+    QStringRef text() const;
+    QXmlStreamNamespaceDeclarations namespaceDeclarations() const;
+    void addExtraNamespaceDeclaration(const QXmlStreamNamespaceDeclaration &extraNamespaceDeclaraction);
+    void addExtraNamespaceDeclarations(const QXmlStreamNamespaceDeclarations &extraNamespaceDeclaractions);
+    QXmlStreamNotationDeclarations notationDeclarations() const;
+    QXmlStreamEntityDeclarations entityDeclarations() const;
+    QStringRef dtdName() const;
+    QStringRef dtdPublicId() const;
+    QStringRef dtdSystemId() const;
+    enum Error {
+        NoError,
+        UnexpectedElementError,
+        CustomError,
+        NotWellFormedError,
+        PrematureEndOfDocumentError
+    };
+    void raiseError(const QString& message = QString());
+    QString errorString() const;
+    Error error() const;
+    inline bool hasError() const
+    {
+        return error() != NoError;
+    }
+    void setEntityResolver(QXmlStreamEntityResolver *resolver);
+    QXmlStreamEntityResolver *entityResolver() const;
+private:
+    QXmlStreamReader(const QXmlStreamReader &); QXmlStreamReader &operator=(const QXmlStreamReader &);
+    inline QXmlStreamReaderPrivate* d_func() { return reinterpret_cast<QXmlStreamReaderPrivate *>(qGetPtrHelper(d_ptr)); } inline const QXmlStreamReaderPrivate* d_func() const { return reinterpret_cast<const QXmlStreamReaderPrivate *>(qGetPtrHelper(d_ptr)); } friend class QXmlStreamReaderPrivate;
+    QScopedPointer<QXmlStreamReaderPrivate> d_ptr;
+};
+class QXmlStreamWriterPrivate;
+class QXmlStreamWriter
+{
+public:
+    QXmlStreamWriter();
+    QXmlStreamWriter(QIODevice *device);
+    QXmlStreamWriter(QByteArray *array);
+    QXmlStreamWriter(QString *string);
+    ~QXmlStreamWriter();
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+    void setCodec(QTextCodec *codec);
+    void setCodec(const char *codecName);
+    QTextCodec *codec() const;
+    void setAutoFormatting(bool);
+    bool autoFormatting() const;
+    void setAutoFormattingIndent(int spacesOrTabs);
+    int autoFormattingIndent() const;
+    void writeAttribute(const QString &qualifiedName, const QString &value);
+    void writeAttribute(const QString &namespaceUri, const QString &name, const QString &value);
+    void writeAttribute(const QXmlStreamAttribute& attribute);
+    void writeAttributes(const QXmlStreamAttributes& attributes);
+    void writeCDATA(const QString &text);
+    void writeCharacters(const QString &text);
+    void writeComment(const QString &text);
+    void writeDTD(const QString &dtd);
+    void writeEmptyElement(const QString &qualifiedName);
+    void writeEmptyElement(const QString &namespaceUri, const QString &name);
+    void writeTextElement(const QString &qualifiedName, const QString &text);
+    void writeTextElement(const QString &namespaceUri, const QString &name, const QString &text);
+    void writeEndDocument();
+    void writeEndElement();
+    void writeEntityReference(const QString &name);
+    void writeNamespace(const QString &namespaceUri, const QString &prefix = QString());
+    void writeDefaultNamespace(const QString &namespaceUri);
+    void writeProcessingInstruction(const QString &target, const QString &data = QString());
+    void writeStartDocument();
+    void writeStartDocument(const QString &version);
+    void writeStartDocument(const QString &version, bool standalone);
+    void writeStartElement(const QString &qualifiedName);
+    void writeStartElement(const QString &namespaceUri, const QString &name);
+    void writeCurrentToken(const QXmlStreamReader &reader);
+    bool hasError() const;
+private:
+    QXmlStreamWriter(const QXmlStreamWriter &); QXmlStreamWriter &operator=(const QXmlStreamWriter &);
+    inline QXmlStreamWriterPrivate* d_func() { return reinterpret_cast<QXmlStreamWriterPrivate *>(qGetPtrHelper(d_ptr)); } inline const QXmlStreamWriterPrivate* d_func() const { return reinterpret_cast<const QXmlStreamWriterPrivate *>(qGetPtrHelper(d_ptr)); } friend class QXmlStreamWriterPrivate;
+    QScopedPointer<QXmlStreamWriterPrivate> d_ptr;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTextCodec;
+class QIODevice;
+class QTextDecoder;
+class QTextEncoder;
+class QTextCodec
+{
+    QTextCodec(const QTextCodec &); QTextCodec &operator=(const QTextCodec &);
+public:
+    static QTextCodec* codecForName(const QByteArray &name);
+    static QTextCodec* codecForName(const char *name) { return codecForName(QByteArray(name)); }
+    static QTextCodec* codecForMib(int mib);
+    static QList<QByteArray> availableCodecs();
+    static QList<int> availableMibs();
+    static QTextCodec* codecForLocale();
+    static void setCodecForLocale(QTextCodec *c);
+    static QTextCodec* codecForTr();
+    static void setCodecForTr(QTextCodec *c);
+    static QTextCodec* codecForCStrings();
+    static void setCodecForCStrings(QTextCodec *c);
+    static QTextCodec *codecForHtml(const QByteArray &ba);
+    static QTextCodec *codecForHtml(const QByteArray &ba, QTextCodec *defaultCodec);
+    static QTextCodec *codecForUtfText(const QByteArray &ba);
+    static QTextCodec *codecForUtfText(const QByteArray &ba, QTextCodec *defaultCodec);
+    bool canEncode(QChar) const;
+    bool canEncode(const QString&) const;
+    QString toUnicode(const QByteArray&) const;
+    QString toUnicode(const char* chars) const;
+    QByteArray fromUnicode(const QString& uc) const;
+    enum ConversionFlag {
+        DefaultConversion,
+        ConvertInvalidToNull = 0x80000000,
+        IgnoreHeader = 0x1,
+        FreeFunction = 0x2
+    };
+    typedef QFlags<ConversionFlag> ConversionFlags;
+    struct ConverterState {
+        ConverterState(ConversionFlags f = DefaultConversion)
+            : flags(f), remainingChars(0), invalidChars(0), d(0) { state_data[0] = state_data[1] = state_data[2] = 0; }
+        ~ConverterState();
+        ConversionFlags flags;
+        int remainingChars;
+        int invalidChars;
+        uint state_data[3];
+        void *d;
+    private:
+        ConverterState(const ConverterState &); ConverterState &operator=(const ConverterState &);
+    };
+    QString toUnicode(const char *in, int length, ConverterState *state = 0) const
+        { return convertToUnicode(in, length, state); }
+    QByteArray fromUnicode(const QChar *in, int length, ConverterState *state = 0) const
+        { return convertFromUnicode(in, length, state); }
+    QTextDecoder* makeDecoder() const;
+    QTextDecoder* makeDecoder(ConversionFlags flags) const;
+    QTextEncoder* makeEncoder() const;
+    QTextEncoder* makeEncoder(ConversionFlags flags) const;
+    virtual QByteArray name() const = 0;
+    virtual QList<QByteArray> aliases() const;
+    virtual int mibEnum() const = 0;
+protected:
+    virtual QString convertToUnicode(const char *in, int length, ConverterState *state) const = 0;
+    virtual QByteArray convertFromUnicode(const QChar *in, int length, ConverterState *state) const = 0;
+    QTextCodec();
+    virtual ~QTextCodec();
+public:
+private:
+    friend class QTextCodecCleanup;
+    static QTextCodec *cftr;
+    static bool validCodecs();
+};
+ inline QFlags<QTextCodec::ConversionFlags::enum_type> operator|(QTextCodec::ConversionFlags::enum_type f1, QTextCodec::ConversionFlags::enum_type f2) { return QFlags<QTextCodec::ConversionFlags::enum_type>(f1) | f2; } inline QFlags<QTextCodec::ConversionFlags::enum_type> operator|(QTextCodec::ConversionFlags::enum_type f1, QFlags<QTextCodec::ConversionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextCodec::ConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+        inline QTextCodec* QTextCodec::codecForTr() { return validCodecs() ? cftr : 0; }
+inline void QTextCodec::setCodecForTr(QTextCodec *c) { cftr = c; }
+inline QTextCodec* QTextCodec::codecForCStrings() { return validCodecs() ? QString::codecForCStrings : 0; }
+inline void QTextCodec::setCodecForCStrings(QTextCodec *c) { QString::codecForCStrings = c; }
+class QTextEncoder {
+    QTextEncoder(const QTextEncoder &); QTextEncoder &operator=(const QTextEncoder &);
+public:
+    explicit QTextEncoder(const QTextCodec *codec) : c(codec), state() {}
+    QTextEncoder(const QTextCodec *codec, QTextCodec::ConversionFlags flags);
+    ~QTextEncoder();
+    QByteArray fromUnicode(const QString& str);
+    QByteArray fromUnicode(const QChar *uc, int len);
+    bool hasFailure() const;
+private:
+    const QTextCodec *c;
+    QTextCodec::ConverterState state;
+};
+class QTextDecoder {
+    QTextDecoder(const QTextDecoder &); QTextDecoder &operator=(const QTextDecoder &);
+public:
+    explicit QTextDecoder(const QTextCodec *codec) : c(codec), state() {}
+    QTextDecoder(const QTextCodec *codec, QTextCodec::ConversionFlags flags);
+    ~QTextDecoder();
+    QString toUnicode(const char* chars, int len);
+    QString toUnicode(const QByteArray &ba);
+    void toUnicode(QString *target, const char *chars, int len);
+    bool hasFailure() const;
+private:
+    const QTextCodec *c;
+    QTextCodec::ConverterState state;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <class T>
+class QPointer
+{
+    QObject *o;
+public:
+    inline QPointer() : o(0) {}
+    inline QPointer(T *p) : o(p)
+        { QMetaObject::addGuard(&o); }
+    inline QPointer(const QPointer<T> &p) : o(p.o)
+        { QMetaObject::addGuard(&o); }
+    inline ~QPointer()
+        { QMetaObject::removeGuard(&o); }
+    inline QPointer<T> &operator=(const QPointer<T> &p)
+        { if (this != &p) QMetaObject::changeGuard(&o, p.o); return *this; }
+    inline QPointer<T> &operator=(T* p)
+        { if (o != p) QMetaObject::changeGuard(&o, p); return *this; }
+    inline bool isNull() const
+        { return !o; }
+    inline T* operator->() const
+        { return static_cast<T*>(const_cast<QObject*>(o)); }
+    inline T& operator*() const
+        { return *static_cast<T*>(const_cast<QObject*>(o)); }
+    inline operator T*() const
+        { return static_cast<T*>(const_cast<QObject*>(o)); }
+    inline T* data() const
+        { return static_cast<T*>(const_cast<QObject*>(o)); }
+};
+template <class T>
+inline bool operator==(const T *o, const QPointer<T> &p)
+{ return o == p.operator->(); }
+template<class T>
+inline bool operator==(const QPointer<T> &p, const T *o)
+{ return p.operator->() == o; }
+template <class T>
+inline bool operator==(T *o, const QPointer<T> &p)
+{ return o == p.operator->(); }
+template<class T>
+inline bool operator==(const QPointer<T> &p, T *o)
+{ return p.operator->() == o; }
+template<class T>
+inline bool operator==(const QPointer<T> &p1, const QPointer<T> &p2)
+{ return p1.operator->() == p2.operator->(); }
+template <class T>
+inline bool operator!=(const T *o, const QPointer<T> &p)
+{ return o != p.operator->(); }
+template<class T>
+inline bool operator!= (const QPointer<T> &p, const T *o)
+{ return p.operator->() != o; }
+template <class T>
+inline bool operator!=(T *o, const QPointer<T> &p)
+{ return o != p.operator->(); }
+template<class T>
+inline bool operator!= (const QPointer<T> &p, T *o)
+{ return p.operator->() != o; }
+template<class T>
+inline bool operator!= (const QPointer<T> &p1, const QPointer<T> &p2)
+{ return p1.operator->() != p2.operator->() ; }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+typedef QObject *(*QtPluginInstanceFunction)();
+void qRegisterStaticPluginInstanceFunction(QtPluginInstanceFunction function);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QFactoryInterface
+{
+    virtual ~QFactoryInterface() {}
+    virtual QStringList keys() const = 0;
+};
+template <> inline const char *qobject_interface_iid<QFactoryInterface *>() { return "com.trolltech.Qt.QFactoryInterface"; } template <> inline QFactoryInterface *qobject_cast<QFactoryInterface *>(QObject *object) { return reinterpret_cast<QFactoryInterface *>((object ? object->qt_metacast("com.trolltech.Qt.QFactoryInterface") : 0)); } template <> inline QFactoryInterface *qobject_cast<QFactoryInterface *>(const QObject *object) { return reinterpret_cast<QFactoryInterface *>((object ? const_cast<QObject *>(object)->qt_metacast("com.trolltech.Qt.QFactoryInterface") : 0)); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTextCodec;
+struct QTextCodecFactoryInterface : public QFactoryInterface
+{
+    virtual QTextCodec *create(const QString &key) = 0;
+};
+template <> inline const char *qobject_interface_iid<QTextCodecFactoryInterface *>() { return "com.trolltech.Qt.QTextCodecFactoryInterface"; } template <> inline QTextCodecFactoryInterface *qobject_cast<QTextCodecFactoryInterface *>(QObject *object) { return reinterpret_cast<QTextCodecFactoryInterface *>((object ? object->qt_metacast("com.trolltech.Qt.QTextCodecFactoryInterface") : 0)); } template <> inline QTextCodecFactoryInterface *qobject_cast<QTextCodecFactoryInterface *>(const QObject *object) { return reinterpret_cast<QTextCodecFactoryInterface *>((object ? const_cast<QObject *>(object)->qt_metacast("com.trolltech.Qt.QTextCodecFactoryInterface") : 0)); }
+class QTextCodecPlugin : public QObject, public QTextCodecFactoryInterface
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QTextCodecPlugin(QObject *parent = 0);
+    ~QTextCodecPlugin();
+    virtual QList<QByteArray> names() const = 0;
+    virtual QList<QByteArray> aliases() const = 0;
+    virtual QTextCodec *createForName(const QByteArray &name) = 0;
+    virtual QList<int> mibEnums() const = 0;
+    virtual QTextCodec *createForMib(int mib) = 0;
+private:
+    QStringList keys() const;
+    QTextCodec *create(const QString &name);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QRunnable
+{
+    int ref;
+    friend class QThreadPool;
+    friend class QThreadPoolPrivate;
+    friend class QThreadPoolThread;
+public:
+    virtual void run() = 0;
+    QRunnable() : ref(0) { }
+    virtual ~QRunnable() { }
+    bool autoDelete() const { return ref != -1; }
+    void setAutoDelete(bool _autoDelete) { ref = _autoDelete ? 0 : -1; }
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAtomicInt;
+class QMutexData;
+class QMutex
+{
+    friend class QWaitCondition;
+    friend class QWaitConditionPrivate;
+public:
+    enum RecursionMode { NonRecursive, Recursive };
+    explicit QMutex(RecursionMode mode = NonRecursive);
+    ~QMutex();
+    void lock();
+    inline void lockInline();
+    bool tryLock();
+    bool tryLock(int timeout);
+    inline bool tryLockInline();
+    void unlock();
+    inline void unlockInline();
+private:
+    void lockInternal();
+    void unlockInternal();
+    QMutex(const QMutex &); QMutex &operator=(const QMutex &);
+    QMutexData *d;
+};
+class QMutexLocker
+{
+public:
+    inline explicit QMutexLocker(QMutex *m)
+    {
+        qt_noop()
+                                                                  ;
+        if (m) {
+            m->lockInline();
+            val = reinterpret_cast<quintptr>(m) | quintptr(1u);
+        } else {
+            val = 0;
+        }
+    }
+    inline ~QMutexLocker() { unlock(); }
+    inline void unlock()
+    {
+        if ((val & quintptr(1u)) == quintptr(1u)) {
+            val &= ~quintptr(1u);
+            mutex()->unlockInline();
+        }
+    }
+    inline void relock()
+    {
+        if (val) {
+            if ((val & quintptr(1u)) == quintptr(0u)) {
+                mutex()->lockInline();
+                val |= quintptr(1u);
+            }
+        }
+    }
+    inline QMutex *mutex() const
+    {
+        return reinterpret_cast<QMutex *>(val & ~quintptr(1u));
+    }
+private:
+    QMutexLocker(const QMutexLocker &); QMutexLocker &operator=(const QMutexLocker &);
+    quintptr val;
+};
+class QMutexData
+{
+    public:
+        QAtomicInt contenders;
+        const uint recursive : 1;
+        uint reserved : 31;
+    protected:
+        QMutexData(QMutex::RecursionMode mode);
+        ~QMutexData();
+};
+inline void QMutex::unlockInline()
+{
+    if (d->recursive) {
+        unlock();
+    } else if (!d->contenders.testAndSetRelease(1, 0)) {
+        unlockInternal();
+    }
+}
+inline bool QMutex::tryLockInline()
+{
+    if (d->recursive) {
+        return tryLock();
+    } else {
+        return d->contenders.testAndSetAcquire(0, 1);
+    }
+}
+inline void QMutex::lockInline()
+{
+    if (d->recursive) {
+        lock();
+    } else if(!tryLockInline()) {
+        lockInternal();
+    }
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent
+{
+class Exception : public std::exception
+{
+public:
+    virtual void raise() const;
+    virtual Exception *clone() const;
+};
+class UnhandledException : public Exception
+{
+public:
+    void raise() const;
+    Exception *clone() const;
+};
+namespace internal {
+class Base;
+class ExceptionHolder
+{
+public:
+    ExceptionHolder(Exception *exception = 0);
+    ExceptionHolder(const ExceptionHolder &other);
+    void operator=(const ExceptionHolder &other);
+    ~ExceptionHolder();
+    Exception *exception() const;
+    Base *base;
+};
+class ExceptionStore
+{
+public:
+    void setException(const Exception &e);
+    bool hasException() const;
+    ExceptionHolder exception();
+    void throwPossibleException();
+    bool hasThrown() const;
+    ExceptionHolder exceptionHolder;
+};
+}
+}
+extern "C" {
+typedef struct
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} _G_fpos_t;
+typedef struct
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} _G_fpos64_t;
+typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
+struct _IO_jump_t; struct _IO_FILE;
+typedef void _IO_lock_t;
+struct _IO_marker {
+  struct _IO_marker *_next;
+  struct _IO_FILE *_sbuf;
+  int _pos;
+};
+enum __codecvt_result
+{
+  __codecvt_ok,
+  __codecvt_partial,
+  __codecvt_error,
+  __codecvt_noconv
+};
+struct _IO_FILE {
+  int _flags;
+  char* _IO_read_ptr;
+  char* _IO_read_end;
+  char* _IO_read_base;
+  char* _IO_write_base;
+  char* _IO_write_ptr;
+  char* _IO_write_end;
+  char* _IO_buf_base;
+  char* _IO_buf_end;
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+  struct _IO_marker *_markers;
+  struct _IO_FILE *_chain;
+  int _fileno;
+  int _flags2;
+  __off_t _old_offset;
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+  _IO_lock_t *_lock;
+  __off64_t _offset;
+  void *__pad1;
+  void *__pad2;
+  void *__pad3;
+  void *__pad4;
+  size_t __pad5;
+  int _mode;
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+struct _IO_FILE_plus;
+extern struct _IO_FILE_plus _IO_2_1_stdin_;
+extern struct _IO_FILE_plus _IO_2_1_stdout_;
+extern struct _IO_FILE_plus _IO_2_1_stderr_;
+typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
+typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
+     size_t __n);
+typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
+typedef int __io_close_fn (void *__cookie);
+typedef __io_read_fn cookie_read_function_t;
+typedef __io_write_fn cookie_write_function_t;
+typedef __io_seek_fn cookie_seek_function_t;
+typedef __io_close_fn cookie_close_function_t;
+typedef struct
+{
+  __io_read_fn *read;
+  __io_write_fn *write;
+  __io_seek_fn *seek;
+  __io_close_fn *close;
+} _IO_cookie_io_functions_t;
+typedef _IO_cookie_io_functions_t cookie_io_functions_t;
+struct _IO_cookie_file;
+extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
+        void *__cookie, _IO_cookie_io_functions_t __fns);
+extern "C" {
+extern int __underflow (_IO_FILE *);
+extern int __uflow (_IO_FILE *);
+extern int __overflow (_IO_FILE *, int);
+extern int _IO_getc (_IO_FILE *__fp);
+extern int _IO_putc (int __c, _IO_FILE *__fp);
+extern int _IO_feof (_IO_FILE *__fp) throw ();
+extern int _IO_ferror (_IO_FILE *__fp) throw ();
+extern int _IO_peekc_locked (_IO_FILE *__fp);
+extern void _IO_flockfile (_IO_FILE *) throw ();
+extern void _IO_funlockfile (_IO_FILE *) throw ();
+extern int _IO_ftrylockfile (_IO_FILE *) throw ();
+extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
+   __gnuc_va_list, int *__restrict);
+extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
+    __gnuc_va_list);
+extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
+extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
+extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
+extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
+extern void _IO_free_backup_area (_IO_FILE *) throw ();
+}
+typedef _G_fpos_t fpos_t;
+typedef _G_fpos64_t fpos64_t;
+extern struct _IO_FILE *stdin;
+extern struct _IO_FILE *stdout;
+extern struct _IO_FILE *stderr;
+extern int remove (__const char *__filename) throw ();
+extern int rename (__const char *__old, __const char *__new) throw ();
+extern int renameat (int __oldfd, __const char *__old, int __newfd,
+       __const char *__new) throw ();
+extern FILE *tmpfile (void) __attribute__ ((__warn_unused_result__));
+extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));
+extern char *tmpnam (char *__s) throw () __attribute__ ((__warn_unused_result__));
+extern char *tmpnam_r (char *__s) throw () __attribute__ ((__warn_unused_result__));
+extern char *tempnam (__const char *__dir, __const char *__pfx)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+extern int fclose (FILE *__stream);
+extern int fflush (FILE *__stream);
+extern int fflush_unlocked (FILE *__stream);
+extern int fcloseall (void);
+extern FILE *fopen (__const char *__restrict __filename,
+      __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
+extern FILE *freopen (__const char *__restrict __filename,
+        __const char *__restrict __modes,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern FILE *fopen64 (__const char *__restrict __filename,
+        __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
+extern FILE *freopen64 (__const char *__restrict __filename,
+   __const char *__restrict __modes,
+   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern FILE *fdopen (int __fd, __const char *__modes) throw () __attribute__ ((__warn_unused_result__));
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     __const char *__restrict __modes,
+     _IO_cookie_io_functions_t __io_funcs) throw () __attribute__ ((__warn_unused_result__));
+extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
+  throw () __attribute__ ((__warn_unused_result__));
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () __attribute__ ((__warn_unused_result__));
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+extern void setlinebuf (FILE *__stream) throw ();
+extern int fprintf (FILE *__restrict __stream,
+      __const char *__restrict __format, ...);
+extern int printf (__const char *__restrict __format, ...);
+extern int sprintf (char *__restrict __s,
+      __const char *__restrict __format, ...) throw ();
+extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
+       __gnuc_va_list __arg);
+extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
+extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       __const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        __const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
+extern int __asprintf (char **__restrict __ptr,
+         __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
+extern int asprintf (char **__restrict __ptr,
+       __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
+extern int vdprintf (int __fd, __const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int fscanf (FILE *__restrict __stream,
+     __const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
+extern int scanf (__const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
+extern int sscanf (__const char *__restrict __s,
+     __const char *__restrict __format, ...) throw ();
+extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
+extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
+extern int vsscanf (__const char *__restrict __s,
+      __const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+extern int getchar (void);
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+extern int fgetc_unlocked (FILE *__stream);
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+extern int putchar (int __c);
+extern int fputc_unlocked (int __c, FILE *__stream);
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+extern int getw (FILE *__stream);
+extern int putw (int __w, FILE *__stream);
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __attribute__ ((__warn_unused_result__));
+extern char *gets (char *__s) __attribute__ ((__warn_unused_result__));
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+          size_t *__restrict __n, int __delimiter,
+          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern __ssize_t getdelim (char **__restrict __lineptr,
+        size_t *__restrict __n, int __delimiter,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern __ssize_t getline (char **__restrict __lineptr,
+       size_t *__restrict __n,
+       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
+extern int puts (__const char *__s);
+extern int ungetc (int __c, FILE *__stream);
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s) __attribute__ ((__warn_unused_result__));
+extern int fputs_unlocked (__const char *__restrict __s,
+      FILE *__restrict __stream);
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern int fseek (FILE *__stream, long int __off, int __whence);
+extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));
+extern void rewind (FILE *__stream);
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_result__));
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
+extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
+extern void clearerr (FILE *__stream) throw ();
+extern int feof (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern int ferror (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern void clearerr_unlocked (FILE *__stream) throw ();
+extern int feof_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern int ferror_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern void perror (__const char *__s);
+extern int sys_nerr;
+extern __const char *__const sys_errlist[];
+extern int _sys_nerr;
+extern __const char *__const _sys_errlist[];
+extern int fileno (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern int fileno_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern FILE *popen (__const char *__command, __const char *__modes) __attribute__ ((__warn_unused_result__));
+extern int pclose (FILE *__stream);
+extern char *ctermid (char *__s) throw ();
+extern char *cuserid (char *__s);
+struct obstack;
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      __const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       __const char *__restrict __format,
+       __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
+extern void flockfile (FILE *__stream) throw ();
+extern int ftrylockfile (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern void funlockfile (FILE *__stream) throw ();
+extern __inline __attribute__ ((__gnu_inline__)) int
+getchar (void)
+{
+  return _IO_getc (stdin);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+fgetc_unlocked (FILE *__fp)
+{
+  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+getc_unlocked (FILE *__fp)
+{
+  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+getchar_unlocked (void)
+{
+  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+putchar (int __c)
+{
+  return _IO_putc (__c, stdout);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+fputc_unlocked (int __c, FILE *__stream)
+{
+  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+putc_unlocked (int __c, FILE *__stream)
+{
+  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+putchar_unlocked (int __c)
+{
+  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
+}
+extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
+getline (char **__lineptr, size_t *__n, FILE *__stream)
+{
+  return __getdelim (__lineptr, __n, '\n', __stream);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
+{
+  return (((__stream)->_flags & 0x10) != 0);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
+{
+  return (((__stream)->_flags & 0x20) != 0);
+}
+extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
+     __const char *__restrict __format, ...) throw ();
+extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
+      __const char *__restrict __format,
+      __gnuc_va_list __ap) throw ();
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) sprintf (char *__restrict __s, __const char *__restrict __fmt, ...) throw ()
+{
+  return __builtin___sprintf_chk (__s, 2 - 1,
+      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) vsprintf (char *__restrict __s, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+{
+  return __builtin___vsprintf_chk (__s, 2 - 1,
+       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
+}
+extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
+      size_t __slen, __const char *__restrict __format,
+      ...) throw ();
+extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
+       size_t __slen, __const char *__restrict __format,
+       __gnuc_va_list __ap) throw ();
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) snprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, ...) throw ()
+{
+  return __builtin___snprintf_chk (__s, __n, 2 - 1,
+       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) vsnprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+{
+  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
+        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
+}
+extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
+     __const char *__restrict __format, ...);
+extern int __printf_chk (int __flag, __const char *__restrict __format, ...);
+extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
+      __const char *__restrict __format, __gnuc_va_list __ap);
+extern int __vprintf_chk (int __flag, __const char *__restrict __format,
+     __gnuc_va_list __ap);
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+fprintf (FILE *__restrict __stream, __const char *__restrict __fmt, ...)
+{
+  return __fprintf_chk (__stream, 2 - 1, __fmt,
+   __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+printf (__const char *__restrict __fmt, ...)
+{
+  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vprintf (__const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vfprintf (FILE *__restrict __stream,
+   __const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
+}
+extern int __asprintf_chk (char **__restrict __ptr, int __flag,
+      __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
+extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
+       __const char *__restrict __fmt, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
+extern int __dprintf_chk (int __fd, int __flag, __const char *__restrict __fmt,
+     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int __vdprintf_chk (int __fd, int __flag,
+      __const char *__restrict __fmt, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
+     int __flag, __const char *__restrict __format,
+     ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
+      int __flag,
+      __const char *__restrict __format,
+      __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()
+{
+  return __asprintf_chk (__ptr, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) __asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()
+{
+  return __asprintf_chk (__ptr, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+dprintf (int __fd, __const char *__restrict __fmt, ...)
+{
+  return __dprintf_chk (__fd, 2 - 1, __fmt,
+   __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) obstack_printf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, ...) throw ()
+{
+  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
+          __builtin_va_arg_pack ());
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) vasprintf (char **__restrict __ptr, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+{
+  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vdprintf (int __fd, __const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
+}
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__attribute__ ((__leaf__)) obstack_vprintf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+{
+  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
+    __ap);
+}
+extern char *__gets_chk (char *__str, size_t) __attribute__ ((__warn_unused_result__));
+extern char *__gets_warn (char *__str) __asm__ ("" "gets")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use fgets or getline instead, gets can't " "specify buffer size")))
+                               ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+gets (char *__str)
+{
+  if (__builtin_object_size (__str, 2 > 1) != (size_t) -1)
+    return __gets_chk (__str, __builtin_object_size (__str, 2 > 1));
+  return __gets_warn (__str);
+}
+extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
+     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")
+                                        __attribute__ ((__warn_unused_result__));
+extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
+ return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+    }
+  return __fgets_alias (__s, __n, __stream);
+}
+extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
+      size_t __size, size_t __n,
+      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")
+            __attribute__ ((__warn_unused_result__));
+extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+fread (void *__restrict __ptr, size_t __size, size_t __n,
+       FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size)
+   || !__builtin_constant_p (__n)
+   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
+ return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
+      if (__size * __n > __builtin_object_size (__ptr, 0))
+ return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
+    }
+  return __fread_alias (__ptr, __size, __n, __stream);
+}
+extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
+       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")
+                                                 __attribute__ ((__warn_unused_result__));
+extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
+                                 ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
+ return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+    }
+  return __fgets_unlocked_alias (__s, __n, __stream);
+}
+extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
+        size_t __size, size_t __n,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")
+                     __attribute__ ((__warn_unused_result__));
+extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
+                                        ;
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
+  FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size)
+   || !__builtin_constant_p (__n)
+   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
+ return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
+         __stream);
+      if (__size * __n > __builtin_object_size (__ptr, 0))
+ return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
+       __stream);
+    }
+  if (__builtin_constant_p (__size)
+      && __builtin_constant_p (__n)
+      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
+      && __size * __n <= 8)
+    {
+      size_t __cnt = __size * __n;
+      char *__cptr = (char *) __ptr;
+      if (__cnt == 0)
+ return 0;
+      for (; __cnt > 0; --__cnt)
+ {
+   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
+   if (__c == (-1))
+     break;
+   *__cptr++ = __c;
+ }
+      return (__cptr - (char *) __ptr) / __size;
+    }
+  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTextCodec;
+class QTextDecoder;
+class QTextStreamPrivate;
+class QTextStream
+{
+    inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } friend class QTextStreamPrivate;
+public:
+    enum RealNumberNotation {
+        SmartNotation,
+        FixedNotation,
+        ScientificNotation
+    };
+    enum FieldAlignment {
+        AlignLeft,
+        AlignRight,
+        AlignCenter,
+        AlignAccountingStyle
+    };
+    enum Status {
+        Ok,
+        ReadPastEnd,
+        ReadCorruptData,
+        WriteFailed
+    };
+    enum NumberFlag {
+        ShowBase = 0x1,
+        ForcePoint = 0x2,
+        ForceSign = 0x4,
+        UppercaseBase = 0x8,
+        UppercaseDigits = 0x10
+    };
+    typedef QFlags<NumberFlag> NumberFlags;
+    QTextStream();
+    explicit QTextStream(QIODevice *device);
+    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
+    virtual ~QTextStream();
+    void setCodec(QTextCodec *codec);
+    void setCodec(const char *codecName);
+    QTextCodec *codec() const;
+    void setAutoDetectUnicode(bool enabled);
+    bool autoDetectUnicode() const;
+    void setGenerateByteOrderMark(bool generate);
+    bool generateByteOrderMark() const;
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    QString *string() const;
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+    bool atEnd() const;
+    void reset();
+    void flush();
+    bool seek(qint64 pos);
+    qint64 pos() const;
+    void skipWhiteSpace();
+    QString readLine(qint64 maxlen = 0);
+    QString readAll();
+    QString read(qint64 maxlen);
+    void setFieldAlignment(FieldAlignment alignment);
+    FieldAlignment fieldAlignment() const;
+    void setPadChar(QChar ch);
+    QChar padChar() const;
+    void setFieldWidth(int width);
+    int fieldWidth() const;
+    void setNumberFlags(NumberFlags flags);
+    NumberFlags numberFlags() const;
+    void setIntegerBase(int base);
+    int integerBase() const;
+    void setRealNumberNotation(RealNumberNotation notation);
+    RealNumberNotation realNumberNotation() const;
+    void setRealNumberPrecision(int precision);
+    int realNumberPrecision() const;
+    QTextStream &operator>>(QChar &ch);
+    QTextStream &operator>>(char &ch);
+    QTextStream &operator>>(signed short &i);
+    QTextStream &operator>>(unsigned short &i);
+    QTextStream &operator>>(signed int &i);
+    QTextStream &operator>>(unsigned int &i);
+    QTextStream &operator>>(signed long &i);
+    QTextStream &operator>>(unsigned long &i);
+    QTextStream &operator>>(qlonglong &i);
+    QTextStream &operator>>(qulonglong &i);
+    QTextStream &operator>>(float &f);
+    QTextStream &operator>>(double &f);
+    QTextStream &operator>>(QString &s);
+    QTextStream &operator>>(QByteArray &array);
+    QTextStream &operator>>(char *c);
+    QTextStream &operator<<(QBool b);
+    QTextStream &operator<<(QChar ch);
+    QTextStream &operator<<(char ch);
+    QTextStream &operator<<(signed short i);
+    QTextStream &operator<<(unsigned short i);
+    QTextStream &operator<<(signed int i);
+    QTextStream &operator<<(unsigned int i);
+    QTextStream &operator<<(signed long i);
+    QTextStream &operator<<(unsigned long i);
+    QTextStream &operator<<(qlonglong i);
+    QTextStream &operator<<(qulonglong i);
+    QTextStream &operator<<(float f);
+    QTextStream &operator<<(double f);
+    QTextStream &operator<<(const QString &s);
+    QTextStream &operator<<(const QByteArray &array);
+    QTextStream &operator<<(const char *c);
+    QTextStream &operator<<(const void *ptr);
+private:
+    QTextStream(const QTextStream &); QTextStream &operator=(const QTextStream &);
+    QScopedPointer<QTextStreamPrivate> d_ptr;
+};
+ inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QTextStream & (*QTextStreamFunction)(QTextStream &);
+typedef void (QTextStream::*QTSMFI)(int);
+typedef void (QTextStream::*QTSMFC)(QChar);
+class QTextStreamManipulator
+{
+public:
+    QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; }
+    QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; arg = -1; }
+    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }
+private:
+    QTSMFI mf;
+    QTSMFC mc;
+    int arg;
+    QChar ch;
+};
+inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
+{ m.exec(s); return s; }
+ QTextStream &bin(QTextStream &s);
+ QTextStream &oct(QTextStream &s);
+ QTextStream &dec(QTextStream &s);
+ QTextStream &hex(QTextStream &s);
+ QTextStream &showbase(QTextStream &s);
+ QTextStream &forcesign(QTextStream &s);
+ QTextStream &forcepoint(QTextStream &s);
+ QTextStream &noshowbase(QTextStream &s);
+ QTextStream &noforcesign(QTextStream &s);
+ QTextStream &noforcepoint(QTextStream &s);
+ QTextStream &uppercasebase(QTextStream &s);
+ QTextStream &uppercasedigits(QTextStream &s);
+ QTextStream &lowercasebase(QTextStream &s);
+ QTextStream &lowercasedigits(QTextStream &s);
+ QTextStream &fixed(QTextStream &s);
+ QTextStream &scientific(QTextStream &s);
+ QTextStream &left(QTextStream &s);
+ QTextStream &right(QTextStream &s);
+ QTextStream &center(QTextStream &s);
+ QTextStream &endl(QTextStream &s);
+ QTextStream &flush(QTextStream &s);
+ QTextStream &reset(QTextStream &s);
+ QTextStream &bom(QTextStream &s);
+ QTextStream &ws(QTextStream &s);
+inline QTextStreamManipulator qSetFieldWidth(int width)
+{
+    QTSMFI func = &QTextStream::setFieldWidth;
+    return QTextStreamManipulator(func,width);
+}
+inline QTextStreamManipulator qSetPadChar(QChar ch)
+{
+    QTSMFC func = &QTextStream::setPadChar;
+    return QTextStreamManipulator(func, ch);
+}
+inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
+{
+    QTSMFI func = &QTextStream::setRealNumberPrecision;
+    return QTextStreamManipulator(func, precision);
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDebug
+{
+    struct Stream {
+        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {}
+        QTextStream ts;
+        QString buffer;
+        int ref;
+        QtMsgType type;
+        bool space;
+        bool message_output;
+    } *stream;
+public:
+    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
+    inline QDebug(QString *string) : stream(new Stream(string)) {}
+    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
+    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
+    inline QDebug &operator=(const QDebug &other);
+    inline ~QDebug() {
+        if (!--stream->ref) {
+            if(stream->message_output) {
+                try {
+                    qt_message_output(stream->type, stream->buffer.toLocal8Bit().data());
+                } catch (std::bad_alloc&) { }
+            }
+            delete stream;
+        }
+    }
+    inline QDebug &space() { stream->space = true; stream->ts << ' '; return *this; }
+    inline QDebug &nospace() { stream->space = false; return *this; }
+    inline QDebug &maybeSpace() { if (stream->space) stream->ts << ' '; return *this; }
+    inline QDebug &operator<<(QChar t) { stream->ts << '\'' << t << '\''; return maybeSpace(); }
+    inline QDebug &operator<<(QBool t) { stream->ts << (bool(t != 0) ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(qint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(quint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(const char* t) { stream->ts << QString::fromAscii(t); return maybeSpace(); }
+    inline QDebug &operator<<(const QString & t) { stream->ts << '\"' << t << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const QStringRef & t) { return operator<<(t.toString()); }
+    inline QDebug &operator<<(const QLatin1String &t) { stream->ts << '\"' << t.latin1() << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const QByteArray & t) { stream->ts << '\"' << t << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(QTextStreamFunction f) {
+        stream->ts << f;
+        return *this;
+    }
+    inline QDebug &operator<<(QTextStreamManipulator m)
+    { stream->ts << m; return *this; }
+};
+class QNoDebug
+{
+public:
+    inline QNoDebug(){}
+    inline QNoDebug(const QDebug &){}
+    inline ~QNoDebug(){}
+    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
+    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }
+    inline QNoDebug &space() { return *this; }
+    inline QNoDebug &nospace() { return *this; }
+    inline QNoDebug &maybeSpace() { return *this; }
+    template<typename T>
+    inline QNoDebug &operator<<(const T &) { return *this; }
+};
+ inline QDebug qCritical() { return QDebug(QtCriticalMsg); }
+inline QDebug &QDebug::operator=(const QDebug &other)
+{
+    if (this != &other) {
+        QDebug copy(other);
+        qSwap(stream, copy.stream);
+    }
+    return *this;
+}
+template <class T>
+inline QDebug operator<<(QDebug debug, const QList<T> &list)
+{
+    debug.nospace() << '(';
+    for (typename QList<T>::size_type i = 0; i < list.count(); ++i) {
+        if (i)
+            debug << ", ";
+        debug << list.at(i);
+    }
+    debug << ')';
+    return debug.space();
+}
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
+{
+    debug.nospace() << "QVector";
+    return operator<<(debug, vec.toList());
+}
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QMap<aKey, aT> &map)
+{
+    debug.nospace() << "QMap(";
+    for (typename QMap<aKey, aT>::const_iterator it = map.constBegin();
+         it != map.constEnd(); ++it) {
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    }
+    debug << ')';
+    return debug.space();
+}
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QHash<aKey, aT> &hash)
+{
+    debug.nospace() << "QHash(";
+    for (typename QHash<aKey, aT>::const_iterator it = hash.constBegin();
+            it != hash.constEnd(); ++it)
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    debug << ')';
+    return debug.space();
+}
+template <class T1, class T2>
+inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
+{
+    debug.nospace() << "QPair(" << pair.first << ',' << pair.second << ')';
+    return debug.space();
+}
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QSet<T> &set)
+{
+    debug.nospace() << "QSet";
+    return operator<<(debug, set.toList());
+}
+template <class T>
+inline QDebug operator<<(QDebug debug, const QContiguousCache<T> &cache)
+{
+    debug.nospace() << "QContiguousCache(";
+    for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
+        debug << cache[i];
+        if (i != cache.lastIndex())
+            debug << ", ";
+    }
+    debug << ')';
+    return debug.space();
+}
+template <class T>
+inline QDebug operator<<(QDebug debug, const QFlags<T> &flags)
+{
+    debug.nospace() << "QFlags(";
+    bool needSeparator = false;
+    for (uint i = 0; i < sizeof(T) * 8; ++i) {
+        if (flags.testFlag(T(1 << i))) {
+            if (needSeparator)
+                debug.nospace() << '|';
+            else
+                needSeparator = true;
+            debug.nospace() << "0x" << QByteArray::number(T(1 << i), 16).constData();
+        }
+    }
+    debug << ')';
+    return debug.space();
+}
+ inline QDebug qDebug() { return QDebug(QtDebugMsg); }
+ inline QDebug qWarning() { return QDebug(QtWarningMsg); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+class ResultItem
+{
+public:
+    ResultItem(const void *_result, int _count) : m_count(_count), result(_result) { }
+    ResultItem(const void *_result) : m_count(0), result(_result) { }
+    ResultItem() : m_count(0), result(0) { }
+    bool isValid() const { return result != 0; }
+    bool isVector() const { return m_count != 0; }
+    int count() const { return (m_count == 0) ? 1 : m_count; }
+    int m_count;
+    const void *result;
+};
+class ResultIteratorBase
+{
+public:
+    ResultIteratorBase();
+    ResultIteratorBase(QMap<int, ResultItem>::const_iterator _mapIterator, int _vectorIndex = 0);
+    int vectorIndex() const;
+    int resultIndex() const;
+    ResultIteratorBase operator++();
+    int batchSize() const;
+    void batchedAdvance();
+    bool operator==(const ResultIteratorBase &other) const;
+    bool operator!=(const ResultIteratorBase &other) const;
+    bool isVector() const;
+    bool canIncrementVectorIndex() const;
+protected:
+    QMap<int, ResultItem>::const_iterator mapIterator;
+    int m_vectorIndex;
+};
+template <typename T>
+class ResultIterator : public ResultIteratorBase
+{
+public:
+    ResultIterator(const ResultIteratorBase &base)
+    : ResultIteratorBase(base) { }
+    const T &value() const
+    {
+        return *pointer();
+    }
+    const T *pointer() const
+    {
+        if (mapIterator.value().isVector())
+            return &(reinterpret_cast<const QVector<T> *>(mapIterator.value().result)->at(m_vectorIndex));
+        else
+            return reinterpret_cast<const T *>(mapIterator.value().result);
+    }
+};
+class ResultStoreBase
+{
+public:
+    ResultStoreBase();
+    void setFilterMode(bool enable);
+    bool filterMode() const;
+    int addResult(int index, const void *result);
+    int addResults(int index, const void *results, int vectorSize, int logicalCount);
+    ResultIteratorBase begin() const;
+    ResultIteratorBase end() const;
+    bool hasNextResult() const;
+    ResultIteratorBase resultAt(int index) const;
+    bool contains(int index) const;
+    int count() const;
+    virtual ~ResultStoreBase() { };
+protected:
+    int insertResultItem(int index, ResultItem &resultItem);
+    void insertResultItemIfValid(int index, ResultItem &resultItem);
+    void syncPendingResults();
+    void syncResultCount();
+    int updateInsertIndex(int index, int _count);
+    QMap<int, ResultItem> m_results;
+    int insertIndex;
+    int resultCount;
+    bool m_filterMode;
+    QMap<int, ResultItem> pendingResults;
+    int filteredResults;
+};
+template <typename T>
+class ResultStore : public ResultStoreBase
+{
+public:
+    ResultStore() { }
+    ResultStore(const ResultStoreBase &base)
+    : ResultStoreBase(base) { }
+    int addResult(int index, const T *result)
+    {
+        if (result == 0)
+            return ResultStoreBase::addResult(index, result);
+        else
+            return ResultStoreBase::addResult(index, new T(*result));
+    }
+    int addResults(int index, const QVector<T> *results)
+    {
+        return ResultStoreBase::addResults(index, new QVector<T>(*results), results->count(), results->count());
+    }
+    int addResults(int index, const QVector<T> *results, int totalCount)
+    {
+        if (m_filterMode && totalCount && !results->count())
+            return ResultStoreBase::addResults(index, 0, 0, totalCount);
+        else
+            return ResultStoreBase::addResults(index, new QVector<T>(*results), results->count(), totalCount);
+    }
+    int addCanceledResult(int index)
+    {
+        return addResult(index, 0);
+    }
+    int addCanceledResults(int index, int _count)
+    {
+        QVector<T> empty;
+        return addResults(index, &empty, _count);
+    }
+    ResultIterator<T> begin() const
+    {
+        return static_cast<ResultIterator<T> >(ResultStoreBase::begin());
+    }
+    ResultIterator<T> end() const
+    {
+        return static_cast<ResultIterator<T> >(ResultStoreBase::end());
+    }
+    ResultIterator<T> resultAt(int index) const
+    {
+        return static_cast<ResultIterator<T> >(ResultStoreBase::resultAt(index));
+    }
+    void clear()
+    {
+        QMap<int, ResultItem>::const_iterator mapIterator = m_results.constBegin();
+        while (mapIterator != m_results.constEnd()) {
+            if (mapIterator.value().isVector())
+                delete reinterpret_cast<const QVector<T> *>(mapIterator.value().result);
+            else
+                delete reinterpret_cast<const T *>(mapIterator.value().result);
+            ++mapIterator;
+        }
+        resultCount = 0;
+        m_results.clear();
+    }
+    ~ResultStore()
+    {
+        clear();
+    }
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T> class QFuture;
+class QFutureInterfaceBasePrivate;
+class QFutureWatcherBase;
+class QFutureWatcherBasePrivate;
+class QFutureInterfaceBase
+{
+public:
+    enum State {
+        NoState = 0x00,
+        Running = 0x01,
+        Started = 0x02,
+        Finished = 0x04,
+        Canceled = 0x08,
+        Paused = 0x10,
+        Throttled = 0x20
+    };
+    QFutureInterfaceBase(State initialState = NoState);
+    QFutureInterfaceBase(const QFutureInterfaceBase &other);
+    virtual ~QFutureInterfaceBase();
+    void reportStarted();
+    void reportFinished();
+    void reportCanceled();
+    void reportException(const QtConcurrent::Exception &e);
+    void reportResultsReady(int beginIndex, int endIndex);
+    void setRunnable(QRunnable *runnable);
+    void setFilterMode(bool enable);
+    void setProgressRange(int minimum, int maximum);
+    int progressMinimum() const;
+    int progressMaximum() const;
+    bool isProgressUpdateNeeded() const;
+    void setProgressValue(int progressValue);
+    int progressValue() const;
+    void setProgressValueAndText(int progressValue, const QString &progressText);
+    QString progressText() const;
+    void setExpectedResultCount(int resultCount);
+    int expectedResultCount();
+    int resultCount() const;
+    bool queryState(State state) const;
+    bool isRunning() const;
+    bool isStarted() const;
+    bool isCanceled() const;
+    bool isFinished() const;
+    bool isPaused() const;
+    bool isThrottled() const;
+    bool isResultReadyAt(int index) const;
+    void cancel();
+    void setPaused(bool paused);
+    void togglePaused();
+    void setThrottled(bool enable);
+    void waitForFinished();
+    bool waitForNextResult();
+    void waitForResult(int resultIndex);
+    void waitForResume();
+    QMutex *mutex() const;
+    QtConcurrent::internal::ExceptionStore &exceptionStore();
+    QtConcurrent::ResultStoreBase &resultStoreBase();
+    const QtConcurrent::ResultStoreBase &resultStoreBase() const;
+    inline bool operator==(const QFutureInterfaceBase &other) const { return d == other.d; }
+    inline bool operator!=(const QFutureInterfaceBase &other) const { return d != other.d; }
+    QFutureInterfaceBase &operator=(const QFutureInterfaceBase &other);
+protected:
+    bool referenceCountIsOne() const;
+public:
+private:
+    QFutureInterfaceBasePrivate *d;
+private:
+    friend class QFutureWatcherBase;
+    friend class QFutureWatcherBasePrivate;
+};
+template <typename T>
+class QFutureInterface : public QFutureInterfaceBase
+{
+public:
+    QFutureInterface(State initialState = NoState)
+        : QFutureInterfaceBase(initialState)
+    { }
+    QFutureInterface(const QFutureInterface &other)
+        : QFutureInterfaceBase(other)
+    { }
+    ~QFutureInterface()
+    {
+        if (referenceCountIsOne())
+            resultStore().clear();
+    }
+    static QFutureInterface canceledResult()
+    { return QFutureInterface(State(Started | Finished | Canceled)); }
+    QFutureInterface &operator=(const QFutureInterface &other)
+    {
+        if (referenceCountIsOne())
+            resultStore().clear();
+        QFutureInterfaceBase::operator=(other);
+        return *this;
+    }
+    inline QFuture<T> future();
+    inline void reportResult(const T *result, int index = -1);
+    inline void reportResult(const T &result, int index = -1);
+    inline void reportResults(const QVector<T> &results, int beginIndex = -1, int count = -1);
+    inline void reportFinished(const T *result = 0);
+    inline const T &resultReference(int index) const;
+    inline const T *resultPointer(int index) const;
+    inline QList<T> results();
+private:
+    QtConcurrent::ResultStore<T> &resultStore()
+    { return static_cast<QtConcurrent::ResultStore<T> &>(resultStoreBase()); }
+    const QtConcurrent::ResultStore<T> &resultStore() const
+    { return static_cast<const QtConcurrent::ResultStore<T> &>(resultStoreBase()); }
+};
+template <typename T>
+inline void QFutureInterface<T>::reportResult(const T *result, int index)
+{
+    QMutexLocker locker(mutex());
+    if (this->queryState(Canceled) || this->queryState(Finished)) {
+        return;
+    }
+    QtConcurrent::ResultStore<T> &store = resultStore();
+    if (store.filterMode()) {
+        const int resultCountBefore = store.count();
+        store.addResult(index, result);
+        this->reportResultsReady(resultCountBefore, resultCountBefore + store.count());
+    } else {
+        const int insertIndex = store.addResult(index, result);
+        this->reportResultsReady(insertIndex, insertIndex + 1);
+    }
+}
+template <typename T>
+inline void QFutureInterface<T>::reportResult(const T &result, int index)
+{
+    reportResult(&result, index);
+}
+template <typename T>
+inline void QFutureInterface<T>::reportResults(const QVector<T> &_results, int beginIndex, int count)
+{
+    QMutexLocker locker(mutex());
+    if (this->queryState(Canceled) || this->queryState(Finished)) {
+        return;
+    }
+    QtConcurrent::ResultStore<T> &store = resultStore();
+    if (store.filterMode()) {
+        const int resultCountBefore = store.count();
+        store.addResults(beginIndex, &_results, count);
+        this->reportResultsReady(resultCountBefore, store.count());
+    } else {
+        const int insertIndex = store.addResults(beginIndex, &_results, count);
+        this->reportResultsReady(insertIndex, insertIndex + _results.count());
+    }
+}
+template <typename T>
+inline void QFutureInterface<T>::reportFinished(const T *result)
+{
+    if (result)
+        reportResult(result);
+    QFutureInterfaceBase::reportFinished();
+}
+template <typename T>
+inline const T &QFutureInterface<T>::resultReference(int index) const
+{
+    QMutexLocker lock(mutex());
+    return resultStore().resultAt(index).value();
+}
+template <typename T>
+inline const T *QFutureInterface<T>::resultPointer(int index) const
+{
+    QMutexLocker lock(mutex());
+    return resultStore().resultAt(index).pointer();
+}
+template <typename T>
+inline QList<T> QFutureInterface<T>::results()
+{
+    if (this->isCanceled()) {
+        exceptionStore().throwPossibleException();
+        return QList<T>();
+    }
+    QFutureInterfaceBase::waitForResult(-1);
+    QList<T> res;
+    QMutexLocker lock(mutex());
+    QtConcurrent::ResultIterator<T> it = resultStore().begin();
+    while (it != resultStore().end()) {
+        res.append(it.value());
+        ++it;
+    }
+    return res;
+}
+template <>
+class QFutureInterface<void> : public QFutureInterfaceBase
+{
+public:
+    QFutureInterface<void>(State initialState = NoState)
+        : QFutureInterfaceBase(initialState)
+    { }
+    QFutureInterface<void>(const QFutureInterface<void> &other)
+        : QFutureInterfaceBase(other)
+    { }
+    static QFutureInterface<void> canceledResult()
+    { return QFutureInterface(State(Started | Finished | Canceled)); }
+    QFutureInterface<void> &operator=(const QFutureInterface<void> &other)
+    {
+        QFutureInterfaceBase::operator=(other);
+        return *this;
+    }
+    inline QFuture<void> future();
+    void reportResult(const void *, int) { }
+    void reportResults(const QVector<void> &, int) { }
+    void reportFinished(void * = 0) { QFutureInterfaceBase::reportFinished(); }
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtPrivate {
+template<class T>
+class HasResultType {
+    typedef char Yes;
+    typedef void *No;
+    template<typename U> static Yes test(int, const typename U::result_type * = 0);
+    template<typename U> static No test(double);
+public:
+    enum { Value = (sizeof(test<T>(0)) == sizeof(Yes)) };
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T>
+class QFutureWatcher;
+template <>
+class QFutureWatcher<void>;
+template <typename T>
+class QFuture
+{
+public:
+    QFuture()
+        : d(QFutureInterface<T>::canceledResult())
+    { }
+    explicit QFuture(QFutureInterface<T> *p)
+        : d(*p)
+    { }
+    QFuture(const QFuture &other)
+        : d(other.d)
+    { }
+    ~QFuture()
+    { }
+    inline QFuture &operator=(const QFuture &other);
+    bool operator==(const QFuture &other) const { return (d == other.d); }
+    bool operator!=(const QFuture &other) const { return (d != other.d); }
+    void cancel() { d.cancel(); }
+    bool isCanceled() const { return d.isCanceled(); }
+    void setPaused(bool paused) { d.setPaused(paused); }
+    bool isPaused() const { return d.isPaused(); }
+    void pause() { setPaused(true); }
+    void resume() { setPaused(false); }
+    void togglePaused() { d.togglePaused(); }
+    bool isStarted() const { return d.isStarted(); }
+    bool isFinished() const { return d.isFinished(); }
+    bool isRunning() const { return d.isRunning(); }
+    int resultCount() const { return d.resultCount(); }
+    int progressValue() const { return d.progressValue(); }
+    int progressMinimum() const { return d.progressMinimum(); }
+    int progressMaximum() const { return d.progressMaximum(); }
+    QString progressText() const { return d.progressText(); }
+    void waitForFinished() { d.waitForFinished(); }
+    inline T result() const;
+    inline T resultAt(int index) const;
+    bool isResultReadyAt(int resultIndex) const { return d.isResultReadyAt(resultIndex); }
+    operator T() const { return result(); }
+    QList<T> results() const { return d.results(); }
+    class const_iterator
+    {
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+        inline const_iterator() {}
+        inline const_iterator(QFuture const * const _future, int _index) : future(_future), index(_index) {}
+        inline const_iterator(const const_iterator &o) : future(o.future), index(o.index) {}
+        inline const_iterator &operator=(const const_iterator &o)
+        { future = o.future; index = o.index; return *this; }
+        inline const T &operator*() const { return future->d.resultReference(index); }
+        inline const T *operator->() const { return future->d.resultPointer(index); }
+        inline bool operator!=(const const_iterator &other) const
+        {
+            if (index == -1 && other.index == -1)
+                return false;
+            if (other.index == -1)
+                return (future->isRunning() || (index < future->resultCount()));
+            return (index != other.index);
+        }
+        inline bool operator==(const const_iterator &o) const { return !operator!=(o); }
+        inline const_iterator &operator++() { ++index; return *this; }
+        inline const_iterator operator++(int) { const_iterator r = *this; ++index; return r; }
+        inline const_iterator &operator--() { --index; return *this; }
+        inline const_iterator operator--(int) { const_iterator r = *this; --index; return r; }
+        inline const_iterator operator+(int j) const { return const_iterator(future, index + j); }
+        inline const_iterator operator-(int j) const { return const_iterator(future, index - j); }
+        inline const_iterator &operator+=(int j) { index += j; return *this; }
+        inline const_iterator &operator-=(int j) { index -= j; return *this; }
+    private:
+        QFuture const * future;
+        int index;
+    };
+    friend class const_iterator;
+    typedef const_iterator ConstIterator;
+    const_iterator begin() const { return const_iterator(this, 0); }
+    const_iterator constBegin() const { return const_iterator(this, 0); }
+    const_iterator end() const { return const_iterator(this, -1); }
+    const_iterator constEnd() const { return const_iterator(this, -1); }
+private:
+    friend class QFutureWatcher<T>;
+public:
+    mutable QFutureInterface<T> d;
+};
+template <typename T>
+inline QFuture<T> &QFuture<T>::operator=(const QFuture<T> &other)
+{
+    d = other.d;
+    return *this;
+}
+template <typename T>
+inline T QFuture<T>::result() const
+{
+    d.waitForResult(0);
+    return d.resultReference(0);
+}
+template <typename T>
+inline T QFuture<T>::resultAt(int index) const
+{
+    d.waitForResult(index);
+    return d.resultReference(index);
+}
+template <typename T>
+inline QFuture<T> QFutureInterface<T>::future()
+{
+    return QFuture<T>(this);
+}
+template <class T> class QFutureIterator { typedef typename QFuture<T>::const_iterator const_iterator; QFuture<T> c; const_iterator i; public: inline QFutureIterator(const QFuture<T> &container) : c(container), i(c.constBegin()) {} inline QFutureIterator &operator=(const QFuture<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <>
+class QFuture<void>
+{
+public:
+    QFuture()
+        : d(QFutureInterface<void>::canceledResult())
+    { }
+    explicit QFuture(QFutureInterfaceBase *p)
+        : d(*p)
+    { }
+    QFuture(const QFuture &other)
+        : d(other.d)
+    { }
+    ~QFuture()
+    { }
+    QFuture &operator=(const QFuture &other);
+    bool operator==(const QFuture &other) const { return (d == other.d); }
+    bool operator!=(const QFuture &other) const { return (d != other.d); }
+    template <typename T>
+    QFuture(const QFuture<T> &other)
+        : d(other.d)
+    { }
+    template <typename T>
+    QFuture<void> &operator=(const QFuture<T> &other)
+    {
+        d = other.d;
+        return *this;
+    }
+    void cancel() { d.cancel(); }
+    bool isCanceled() const { return d.isCanceled(); }
+    void setPaused(bool paused) { d.setPaused(paused); }
+    bool isPaused() const { return d.isPaused(); }
+    void pause() { setPaused(true); }
+    void resume() { setPaused(false); }
+    void togglePaused() { d.togglePaused(); }
+    bool isStarted() const { return d.isStarted(); }
+    bool isFinished() const { return d.isFinished(); }
+    bool isRunning() const { return d.isRunning(); }
+    int resultCount() const { return d.resultCount(); }
+    int progressValue() const { return d.progressValue(); }
+    int progressMinimum() const { return d.progressMinimum(); }
+    int progressMaximum() const { return d.progressMaximum(); }
+    QString progressText() const { return d.progressText(); }
+    void waitForFinished() { d.waitForFinished(); }
+private:
+    friend class QFutureWatcher<void>;
+    mutable QFutureInterfaceBase d;
+};
+inline QFuture<void> &QFuture<void>::operator=(const QFuture<void> &other)
+{
+    d = other.d;
+    return *this;
+}
+inline QFuture<void> QFutureInterface<void>::future()
+{
+    return QFuture<void>(this);
+}
+template <typename T>
+QFuture<void> qToVoidFuture(const QFuture<T> &future)
+{
+    return QFuture<void>(future.d);
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T>
+class QFutureSynchronizer
+{
+    QFutureSynchronizer(const QFutureSynchronizer &); QFutureSynchronizer &operator=(const QFutureSynchronizer &);
+public:
+    QFutureSynchronizer() : m_cancelOnWait(false) { }
+    explicit QFutureSynchronizer(const QFuture<T> &future)
+        : m_cancelOnWait(false)
+    { addFuture(future); }
+    ~QFutureSynchronizer() { waitForFinished(); }
+    void setFuture(const QFuture<T> &future)
+    {
+        waitForFinished();
+        m_futures.clear();
+        addFuture(future);
+    }
+    void addFuture(const QFuture<T> &future)
+    {
+        m_futures.append(future);
+    }
+    void waitForFinished()
+    {
+        if (m_cancelOnWait) {
+            for (int i = 0; i < m_futures.count(); ++i) {
+                 m_futures[i].cancel();
+            }
+        }
+        for (int i = 0; i < m_futures.count(); ++i) {
+             m_futures[i].waitForFinished();
+         }
+    }
+    void clearFutures()
+    {
+        m_futures.clear();
+    }
+    QList<QFuture<T> > futures() const
+    {
+        return m_futures;
+    }
+    void setCancelOnWait(bool enabled)
+    {
+        m_cancelOnWait = enabled;
+    }
+    bool cancelOnWait() const
+    {
+        return m_cancelOnWait;
+    }
+protected:
+    QList<QFuture<T> > m_futures;
+    bool m_cancelOnWait;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEvent;
+class QFutureWatcherBasePrivate;
+class QFutureWatcherBase : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QFutureWatcherBasePrivate* d_func() { return reinterpret_cast<QFutureWatcherBasePrivate *>(qGetPtrHelper(d_ptr)); } inline const QFutureWatcherBasePrivate* d_func() const { return reinterpret_cast<const QFutureWatcherBasePrivate *>(qGetPtrHelper(d_ptr)); } friend class QFutureWatcherBasePrivate;
+public:
+    QFutureWatcherBase(QObject *parent = 0);
+    int progressValue() const;
+    int progressMinimum() const;
+    int progressMaximum() const;
+    QString progressText() const;
+    bool isStarted() const;
+    bool isFinished() const;
+    bool isRunning() const;
+    bool isCanceled() const;
+    bool isPaused() const;
+    void waitForFinished();
+    void setPendingResultsLimit(int limit);
+    bool event(QEvent *event);
+protected:
+    void started();
+    void finished();
+    void canceled();
+    void paused();
+    void resumed();
+    void resultReadyAt(int resultIndex);
+    void resultsReadyAt(int beginIndex, int endIndex);
+    void progressRangeChanged(int minimum, int maximum);
+    void progressValueChanged(int progressValue);
+    void progressTextChanged(const QString &progressText);
+public :
+    void cancel();
+    void setPaused(bool paused);
+    void pause();
+    void resume();
+    void togglePaused();
+protected:
+    void connectNotify (const char * signal);
+    void disconnectNotify (const char * signal);
+    void connectOutputInterface();
+    void disconnectOutputInterface(bool pendingAssignment = false);
+private:
+    virtual const QFutureInterfaceBase &futureInterface() const = 0;
+    virtual QFutureInterfaceBase &futureInterface() = 0;
+};
+template <typename T>
+class QFutureWatcher : public QFutureWatcherBase
+{
+public:
+    QFutureWatcher(QObject *_parent = 0)
+        : QFutureWatcherBase(_parent)
+    { }
+    ~QFutureWatcher()
+    { disconnectOutputInterface(); }
+    void setFuture(const QFuture<T> &future);
+    QFuture<T> future() const
+    { return m_future; }
+    T result() const { return m_future.result(); }
+    T resultAt(int index) const { return m_future.resultAt(index); }
+private:
+    QFuture<T> m_future;
+    const QFutureInterfaceBase &futureInterface() const { return m_future.d; }
+    QFutureInterfaceBase &futureInterface() { return m_future.d; }
+};
+template <typename T>
+inline void QFutureWatcher<T>::setFuture(const QFuture<T> &_future)
+{
+    if (_future == m_future)
+        return;
+    disconnectOutputInterface(true);
+    m_future = _future;
+    connectOutputInterface();
+}
+template <>
+class QFutureWatcher<void> : public QFutureWatcherBase
+{
+public:
+    QFutureWatcher(QObject *_parent = 0)
+        : QFutureWatcherBase(_parent)
+    { }
+    ~QFutureWatcher()
+    { disconnectOutputInterface(); }
+    void setFuture(const QFuture<void> &future);
+    QFuture<void> future() const
+    { return m_future; }
+private:
+    QFuture<void> m_future;
+    const QFutureInterfaceBase &futureInterface() const { return m_future.d; }
+    QFutureInterfaceBase &futureInterface() { return m_future.d; }
+};
+inline void QFutureWatcher<void>::setFuture(const QFuture<void> &_future)
+{
+    if (_future == m_future)
+        return;
+    disconnectOutputInterface(true);
+    m_future = _future;
+    connectOutputInterface();
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T>
+class Median
+{
+public:
+    Median(int _bufferSize)
+        : currentMedian(), bufferSize(_bufferSize), currentIndex(0), valid(false), dirty(true)
+    {
+        values.resize(bufferSize);
+    }
+    void reset()
+    {
+        values.fill(0);
+        currentIndex = 0;
+        valid = false;
+        dirty = true;
+    }
+    void addValue(T value)
+    {
+        currentIndex = ((currentIndex + 1) % bufferSize);
+        if (valid == false && currentIndex % bufferSize == 0)
+            valid = true;
+        const T currentIndexValue = values[currentIndex];
+        if ((currentIndexValue > currentMedian && currentMedian > value)
+            || (currentMedian > currentIndexValue && value > currentMedian)) {
+            dirty = true;
+        }
+        values[currentIndex] = value;
+    }
+    bool isMedianValid() const
+    {
+        return valid;
+    }
+    T median()
+    {
+        if (dirty) {
+            dirty = false;
+            QVector<T> sorted = values;
+            qSort(sorted);
+            currentMedian = sorted.at(bufferSize / 2 + 1);
+        }
+        return currentMedian;
+    }
+private:
+    QVector<T> values;
+    T currentMedian;
+    int bufferSize;
+    int currentIndex;
+    bool valid;
+    bool dirty;
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QThreadData;
+class QThreadPrivate;
+class QThread : public QObject
+{
+public:
+    static Qt::HANDLE currentThreadId();
+    static QThread *currentThread();
+    static int idealThreadCount();
+    static void yieldCurrentThread();
+    explicit QThread(QObject *parent = 0);
+    ~QThread();
+    enum Priority {
+        IdlePriority,
+        LowestPriority,
+        LowPriority,
+        NormalPriority,
+        HighPriority,
+        HighestPriority,
+        TimeCriticalPriority,
+        InheritPriority
+    };
+    void setPriority(Priority priority);
+    Priority priority() const;
+    bool isFinished() const;
+    bool isRunning() const;
+    void setStackSize(uint stackSize);
+    uint stackSize() const;
+    void exit(int retcode = 0);
+public :
+    void start(Priority = InheritPriority);
+    void terminate();
+    void quit();
+public:
+    bool wait(unsigned long time = (9223372036854775807L * 2UL + 1UL));
+protected:
+    void started();
+    void finished();
+    void terminated();
+protected:
+    virtual void run();
+    int exec();
+    static void setTerminationEnabled(bool enabled = true);
+    static void sleep(unsigned long);
+    static void msleep(unsigned long);
+    static void usleep(unsigned long);
+protected:
+    QThread(QThreadPrivate &dd, QObject *parent = 0);
+private:
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QThreadPrivate* d_func() { return reinterpret_cast<QThreadPrivate *>(qGetPtrHelper(d_ptr)); } inline const QThreadPrivate* d_func() const { return reinterpret_cast<const QThreadPrivate *>(qGetPtrHelper(d_ptr)); } friend class QThreadPrivate;
+    static void initialize();
+    static void cleanup();
+    friend class QCoreApplication;
+    friend class QThreadData;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QThreadPoolPrivate;
+class QThreadPool : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QThreadPoolPrivate* d_func() { return reinterpret_cast<QThreadPoolPrivate *>(qGetPtrHelper(d_ptr)); } inline const QThreadPoolPrivate* d_func() const { return reinterpret_cast<const QThreadPoolPrivate *>(qGetPtrHelper(d_ptr)); } friend class QThreadPoolPrivate;
+    friend class QFutureInterfaceBase;
+public:
+    QThreadPool(QObject *parent = 0);
+    ~QThreadPool();
+    static QThreadPool *globalInstance();
+    void start(QRunnable *runnable, int priority = 0);
+    bool tryStart(QRunnable *runnable);
+    int expiryTimeout() const;
+    void setExpiryTimeout(int expiryTimeout);
+    int maxThreadCount() const;
+    void setMaxThreadCount(int maxThreadCount);
+    int activeThreadCount() const;
+    void reserveThread();
+    void releaseThread();
+    void waitForDone();
+    bool waitForDone(int msecs);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QWaitConditionPrivate;
+class QMutex;
+class QReadWriteLock;
+class QWaitCondition
+{
+public:
+    QWaitCondition();
+    ~QWaitCondition();
+    bool wait(QMutex *mutex, unsigned long time = (9223372036854775807L * 2UL + 1UL));
+    bool wait(QReadWriteLock *readWriteLock, unsigned long time = (9223372036854775807L * 2UL + 1UL));
+    void wakeOne();
+    void wakeAll();
+private:
+    QWaitCondition(const QWaitCondition &); QWaitCondition &operator=(const QWaitCondition &);
+    QWaitConditionPrivate * d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSemaphorePrivate;
+class QSemaphore
+{
+public:
+    explicit QSemaphore(int n = 0);
+    ~QSemaphore();
+    void acquire(int n = 1);
+    bool tryAcquire(int n = 1);
+    bool tryAcquire(int n, int timeout);
+    void release(int n = 1);
+    int available() const;
+private:
+    QSemaphore(const QSemaphore &); QSemaphore &operator=(const QSemaphore &);
+    QSemaphorePrivate *d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+class ThreadEngineBarrier
+{
+private:
+    QMutex mutex;
+    QAtomicInt count;
+    QSemaphore semaphore;
+public:
+    ThreadEngineBarrier();
+    void acquire();
+    int release();
+    void wait();
+    int currentCount();
+    bool releaseUnlessLast();
+};
+enum ThreadFunctionResult { ThrottleThread, ThreadFinished };
+class ThreadEngineBase: public QRunnable
+{
+public:
+    ThreadEngineBase();
+    virtual ~ThreadEngineBase();
+    void startSingleThreaded();
+    void startBlocking();
+    void startThread();
+    bool isCanceled();
+    void waitForResume();
+    bool isProgressReportingEnabled();
+    void setProgressValue(int progress);
+    void setProgressRange(int minimum, int maximum);
+    void acquireBarrierSemaphore();
+protected:
+    virtual void start() {}
+    virtual void finish() {}
+    virtual ThreadFunctionResult threadFunction() { return ThreadFinished; }
+    virtual bool shouldStartThread() { return futureInterface ? !futureInterface->isPaused() : true; }
+    virtual bool shouldThrottleThread() { return futureInterface ? futureInterface->isPaused() : false; }
+private:
+    bool startThreadInternal();
+    void startThreads();
+    void threadExit();
+    bool threadThrottleExit();
+    void run();
+    virtual void asynchronousFinish() = 0;
+    void handleException(const QtConcurrent::Exception &exception);
+protected:
+    QFutureInterfaceBase *futureInterface;
+    QThreadPool *threadPool;
+    ThreadEngineBarrier barrier;
+    QtConcurrent::internal::ExceptionStore exceptionStore;
+};
+template <typename T>
+class ThreadEngine : public virtual ThreadEngineBase
+{
+public:
+    typedef T ResultType;
+    virtual T *result() { return 0; }
+    QFutureInterface<T> *futureInterfaceTyped()
+    {
+        return static_cast<QFutureInterface<T> *>(futureInterface);
+    }
+    T *startSingleThreaded()
+    {
+        ThreadEngineBase::startSingleThreaded();
+        return result();
+    }
+    T *startBlocking()
+    {
+        ThreadEngineBase::startBlocking();
+        return result();
+    }
+    QFuture<T> startAsynchronously()
+    {
+        futureInterface = new QFutureInterface<T>();
+        futureInterface->reportStarted();
+        QFuture<T> future = QFuture<T>(futureInterfaceTyped());
+        start();
+        acquireBarrierSemaphore();
+        threadPool->start(this);
+        return future;
+    }
+    void asynchronousFinish()
+    {
+        finish();
+        futureInterfaceTyped()->reportFinished(result());
+        delete futureInterfaceTyped();
+        delete this;
+    }
+    void reportResult(const T *_result, int index = -1)
+    {
+        if (futureInterface)
+            futureInterfaceTyped()->reportResult(_result, index);
+    }
+    void reportResults(const QVector<T> &_result, int index = -1, int count = -1)
+    {
+        if (futureInterface)
+            futureInterfaceTyped()->reportResults(_result, index, count);
+    }
+};
+template <typename T>
+class ThreadEngineStarterBase
+{
+public:
+    ThreadEngineStarterBase(ThreadEngine<T> *_threadEngine)
+    : threadEngine(_threadEngine) { }
+    inline ThreadEngineStarterBase(const ThreadEngineStarterBase &other)
+    : threadEngine(other.threadEngine) { }
+    QFuture<T> startAsynchronously()
+    {
+        return threadEngine->startAsynchronously();
+    }
+    operator QFuture<T>()
+    {
+        return startAsynchronously();
+    }
+protected:
+    ThreadEngine<T> *threadEngine;
+};
+template <typename T>
+class ThreadEngineStarter : public ThreadEngineStarterBase<T>
+{
+    typedef ThreadEngineStarterBase<T> Base;
+    typedef ThreadEngine<T> TypedThreadEngine;
+public:
+    ThreadEngineStarter(TypedThreadEngine *eng)
+        : Base(eng) { }
+    T startBlocking()
+    {
+        T t = *this->threadEngine->startBlocking();
+        delete this->threadEngine;
+        return t;
+    }
+};
+template <>
+class ThreadEngineStarter<void> : public ThreadEngineStarterBase<void>
+{
+public:
+    ThreadEngineStarter<void>(ThreadEngine<void> *_threadEngine)
+    :ThreadEngineStarterBase<void>(_threadEngine) {}
+    void startBlocking()
+    {
+        this->threadEngine->startBlocking();
+        delete this->threadEngine;
+    }
+};
+template <typename ThreadEngine>
+inline ThreadEngineStarter<typename ThreadEngine::ResultType> startThreadEngine(ThreadEngine *threadEngine)
+{
+    return ThreadEngineStarter<typename ThreadEngine::ResultType>(threadEngine);
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+    using std::advance;
+class BlockSizeManager
+{
+public:
+    BlockSizeManager(int iterationCount);
+    void timeBeforeUser();
+    void timeAfterUser();
+    int blockSize();
+private:
+    inline bool blockSizeMaxed()
+    {
+        return (m_blockSize >= maxBlockSize);
+    }
+    const int maxBlockSize;
+    qint64 beforeUser;
+    qint64 afterUser;
+    Median<double> controlPartElapsed;
+    Median<double> userPartElapsed;
+    int m_blockSize;
+};
+template <typename T>
+class ResultReporter
+{
+public:
+    ResultReporter(ThreadEngine<T> *_threadEngine)
+    :threadEngine(_threadEngine)
+    {
+    }
+    void reserveSpace(int resultCount)
+    {
+        currentResultCount = resultCount;
+        vector.resize(qMax(resultCount, vector.count()));
+    }
+    void reportResults(int begin)
+    {
+        const int useVectorThreshold = 4;
+        if (currentResultCount > useVectorThreshold) {
+            vector.resize(currentResultCount);
+            threadEngine->reportResults(vector, begin);
+        } else {
+            for (int i = 0; i < currentResultCount; ++i)
+                threadEngine->reportResult(&vector.at(i), begin + i);
+        }
+    }
+    inline T * getPointer()
+    {
+        return vector.data();
+    }
+    int currentResultCount;
+    ThreadEngine<T> *threadEngine;
+    QVector<T> vector;
+};
+template <>
+class ResultReporter<void>
+{
+public:
+    inline ResultReporter(ThreadEngine<void> *) { }
+    inline void reserveSpace(int) { };
+    inline void reportResults(int) { };
+    inline void * getPointer() { return 0; }
+};
+inline bool selectIteration(std::bidirectional_iterator_tag)
+{
+    return false;
+}
+inline bool selectIteration(std::forward_iterator_tag)
+{
+    return false;
+}
+inline bool selectIteration(std::random_access_iterator_tag)
+{
+    return true;
+}
+template <typename Iterator, typename T>
+class IterateKernel : public ThreadEngine<T>
+{
+public:
+    typedef T ResultType;
+    IterateKernel(Iterator _begin, Iterator _end)
+        : begin(_begin), end(_end), current(_begin), currentIndex(0),
+           forIteration(selectIteration(typename std::iterator_traits<Iterator>::iterator_category())), progressReportingEnabled(true)
+    {
+        iterationCount = forIteration ? std::distance(_begin, _end) : 0;
+    }
+    virtual ~IterateKernel() { }
+    virtual bool runIteration(Iterator it, int index , T *result)
+        { (void)it;; (void)index;; (void)result;; return false; }
+    virtual bool runIterations(Iterator _begin, int beginIndex, int endIndex, T *results)
+        { (void)_begin;; (void)beginIndex;; (void)endIndex;; (void)results;; return false; }
+    void start()
+    {
+        progressReportingEnabled = this->isProgressReportingEnabled();
+        if (progressReportingEnabled && iterationCount > 0)
+            this->setProgressRange(0, iterationCount);
+    }
+    bool shouldStartThread()
+    {
+        if (forIteration)
+            return (currentIndex < iterationCount) && !this->shouldThrottleThread();
+        else
+            return (iteratorThreads == 0);
+    }
+    ThreadFunctionResult threadFunction()
+    {
+        if (forIteration)
+            return this->forThreadFunction();
+        else
+            return this->whileThreadFunction();
+    }
+    ThreadFunctionResult forThreadFunction()
+    {
+        BlockSizeManager blockSizeManager(iterationCount);
+        ResultReporter<T> resultReporter(this);
+        for(;;) {
+            if (this->isCanceled())
+                break;
+            const int currentBlockSize = blockSizeManager.blockSize();
+            if (currentIndex >= iterationCount)
+                break;
+            const int beginIndex = currentIndex.fetchAndAddRelease(currentBlockSize);
+            const int endIndex = qMin(beginIndex + currentBlockSize, iterationCount);
+            if (beginIndex >= endIndex) {
+                break;
+            }
+            this->waitForResume();
+            if (shouldStartThread())
+                this->startThread();
+            const int finalBlockSize = endIndex - beginIndex;
+            resultReporter.reserveSpace(finalBlockSize);
+            blockSizeManager.timeBeforeUser();
+            const bool resultsAvailable = this->runIterations(begin, beginIndex, endIndex, resultReporter.getPointer());
+            blockSizeManager.timeAfterUser();
+            if (resultsAvailable)
+                resultReporter.reportResults(beginIndex);
+            if (progressReportingEnabled) {
+                completed.fetchAndAddAcquire(finalBlockSize);
+                this->setProgressValue(this->completed);
+            }
+            if (this->shouldThrottleThread())
+                return ThrottleThread;
+        }
+        return ThreadFinished;
+    }
+    ThreadFunctionResult whileThreadFunction()
+    {
+        if (iteratorThreads.testAndSetAcquire(0, 1) == false)
+            return ThreadFinished;
+        ResultReporter<T> resultReporter(this);
+        resultReporter.reserveSpace(1);
+        while (current != end) {
+            Iterator prev = current;
+            ++current;
+            int index = currentIndex.fetchAndAddRelaxed(1);
+            iteratorThreads.testAndSetRelease(1, 0);
+            this->waitForResume();
+            if (shouldStartThread())
+                this->startThread();
+            const bool resultAavailable = this->runIteration(prev, index, resultReporter.getPointer());
+            if (resultAavailable)
+                resultReporter.reportResults(index);
+            if (this->shouldThrottleThread())
+                return ThrottleThread;
+            if (iteratorThreads.testAndSetAcquire(0, 1) == false)
+                return ThreadFinished;
+        }
+        return ThreadFinished;
+    }
+public:
+    const Iterator begin;
+    const Iterator end;
+    Iterator current;
+    QAtomicInt currentIndex;
+    bool forIteration;
+    QAtomicInt iteratorThreads;
+    int iterationCount;
+    bool progressReportingEnabled;
+    QAtomicInt completed;
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+enum {
+    ReduceQueueStartLimit = 20,
+    ReduceQueueThrottleLimit = 30
+};
+template <typename T>
+class IntermediateResults
+{
+public:
+    int begin, end;
+    QVector<T> vector;
+};
+enum ReduceOption {
+    UnorderedReduce = 0x1,
+    OrderedReduce = 0x2,
+    SequentialReduce = 0x4
+};
+typedef QFlags<ReduceOption> ReduceOptions;
+ inline QFlags<ReduceOptions::enum_type> operator|(ReduceOptions::enum_type f1, ReduceOptions::enum_type f2) { return QFlags<ReduceOptions::enum_type>(f1) | f2; } inline QFlags<ReduceOptions::enum_type> operator|(ReduceOptions::enum_type f1, QFlags<ReduceOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(ReduceOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+template <typename ReduceFunctor, typename ReduceResultType, typename T>
+class ReduceKernel
+{
+    typedef QMap<int, IntermediateResults<T> > ResultsMap;
+    const ReduceOptions reduceOptions;
+    QMutex mutex;
+    int progress, resultsMapSize, threadCount;
+    ResultsMap resultsMap;
+    bool canReduce(int begin) const
+    {
+        return (((reduceOptions & UnorderedReduce)
+                 && progress == 0)
+                || ((reduceOptions & OrderedReduce)
+                    && progress == begin));
+    }
+    void reduceResult(ReduceFunctor &reduce,
+                      ReduceResultType &r,
+                      const IntermediateResults<T> &result)
+    {
+        for (int i = 0; i < result.vector.size(); ++i) {
+            reduce(r, result.vector.at(i));
+        }
+    }
+    void reduceResults(ReduceFunctor &reduce,
+                       ReduceResultType &r,
+                       ResultsMap &map)
+    {
+        typename ResultsMap::iterator it = map.begin();
+        while (it != map.end()) {
+            reduceResult(reduce, r, it.value());
+            ++it;
+        }
+    }
+public:
+    ReduceKernel(ReduceOptions _reduceOptions)
+        : reduceOptions(_reduceOptions), progress(0), resultsMapSize(0),
+          threadCount(QThreadPool::globalInstance()->maxThreadCount())
+    { }
+    void runReduce(ReduceFunctor &reduce,
+                   ReduceResultType &r,
+                   const IntermediateResults<T> &result)
+    {
+        QMutexLocker locker(&mutex);
+        if (!canReduce(result.begin)) {
+            ++resultsMapSize;
+            resultsMap.insert(result.begin, result);
+            return;
+        }
+        if (reduceOptions & UnorderedReduce) {
+            progress = -1;
+            locker.unlock();
+            reduceResult(reduce, r, result);
+            locker.relock();
+            while (!resultsMap.isEmpty()) {
+                ResultsMap resultsMapCopy = resultsMap;
+                resultsMap.clear();
+                locker.unlock();
+                reduceResults(reduce, r, resultsMapCopy);
+                locker.relock();
+                resultsMapSize -= resultsMapCopy.size();
+            }
+            progress = 0;
+        } else {
+            locker.unlock();
+            reduceResult(reduce, r, result);
+            locker.relock();
+            progress += result.end - result.begin;
+            typename ResultsMap::iterator it = resultsMap.begin();
+            while (it != resultsMap.end()) {
+                if (it.value().begin != progress)
+                    break;
+                locker.unlock();
+                reduceResult(reduce, r, it.value());
+                locker.relock();
+                --resultsMapSize;
+                progress += it.value().end - it.value().begin;
+                it = resultsMap.erase(it);
+            }
+        }
+    }
+    void finish(ReduceFunctor &reduce, ReduceResultType &r)
+    {
+        reduceResults(reduce, r, resultsMap);
+    }
+    inline bool shouldThrottle()
+    {
+        return (resultsMapSize > (ReduceQueueThrottleLimit * threadCount));
+    }
+    inline bool shouldStartThread()
+    {
+        return (resultsMapSize <= (ReduceQueueStartLimit * threadCount));
+    }
+};
+template <typename Sequence, typename Base, typename Functor1, typename Functor2>
+struct SequenceHolder2 : public Base
+{
+    SequenceHolder2(const Sequence &_sequence,
+                    Functor1 functor1,
+                    Functor2 functor2,
+                    ReduceOptions reduceOptions)
+        : Base(_sequence.begin(), _sequence.end(), functor1, functor2, reduceOptions),
+          sequence(_sequence)
+    { }
+    Sequence sequence;
+    void finish()
+    {
+        Base::finish();
+        sequence = Sequence();
+    }
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename Iterator, typename MapFunctor>
+class MapKernel : public IterateKernel<Iterator, void>
+{
+    MapFunctor map;
+public:
+    typedef void ReturnType;
+    MapKernel(Iterator begin, Iterator end, MapFunctor _map)
+        : IterateKernel<Iterator, void>(begin, end), map(_map)
+    { }
+    bool runIteration(Iterator it, int, void *)
+    {
+        map(*it);
+        return false;
+    }
+    bool runIterations(Iterator sequenceBeginIterator, int beginIndex, int endIndex, void *)
+    {
+        Iterator it = sequenceBeginIterator;
+        advance(it, beginIndex);
+        for (int i = beginIndex; i < endIndex; ++i) {
+            runIteration(it, i, 0);
+            advance(it, 1);
+        }
+        return false;
+    }
+};
+template <typename ReducedResultType,
+          typename Iterator,
+          typename MapFunctor,
+          typename ReduceFunctor,
+          typename Reducer = ReduceKernel<ReduceFunctor,
+                                          ReducedResultType,
+                                          typename MapFunctor::result_type> >
+class MappedReducedKernel : public IterateKernel<Iterator, ReducedResultType>
+{
+    ReducedResultType reducedResult;
+    MapFunctor map;
+    ReduceFunctor reduce;
+    Reducer reducer;
+public:
+    typedef ReducedResultType ReturnType;
+    MappedReducedKernel(Iterator begin, Iterator end, MapFunctor _map, ReduceFunctor _reduce, ReduceOptions reduceOptions)
+        : IterateKernel<Iterator, ReducedResultType>(begin, end), reducedResult(), map(_map), reduce(_reduce), reducer(reduceOptions)
+    { }
+    MappedReducedKernel(ReducedResultType initialValue,
+                     MapFunctor _map,
+                     ReduceFunctor _reduce)
+        : reducedResult(initialValue), map(_map), reduce(_reduce)
+    { }
+    bool runIteration(Iterator it, int index, ReducedResultType *)
+    {
+        IntermediateResults<typename MapFunctor::result_type> results;
+        results.begin = index;
+        results.end = index + 1;
+        results.vector.append(map(*it));
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, ReducedResultType *)
+    {
+        IntermediateResults<typename MapFunctor::result_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(end - begin);
+        Iterator it = sequenceBeginIterator;
+        advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            results.vector.append(map(*(it)));
+            advance(it, 1);
+        }
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+    void finish()
+    {
+        reducer.finish(reduce, reducedResult);
+    }
+    bool shouldThrottleThread()
+    {
+        return IterateKernel<Iterator, ReducedResultType>::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+    bool shouldStartThread()
+    {
+        return IterateKernel<Iterator, ReducedResultType>::shouldStartThread() && reducer.shouldStartThread();
+    }
+    typedef ReducedResultType ResultType;
+    ReducedResultType *result()
+    {
+        return &reducedResult;
+    }
+};
+template <typename Iterator, typename MapFunctor>
+class MappedEachKernel : public IterateKernel<Iterator, typename MapFunctor::result_type>
+{
+    MapFunctor map;
+    typedef typename MapFunctor::result_type T;
+public:
+    typedef T ReturnType;
+    typedef T ResultType;
+    MappedEachKernel(Iterator begin, Iterator end, MapFunctor _map)
+        : IterateKernel<Iterator, T>(begin, end), map(_map) { }
+    bool runIteration(Iterator it, int, T *result)
+    {
+        *result = map(*it);
+        return true;
+    }
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, T *results)
+    {
+        Iterator it = sequenceBeginIterator;
+        advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            runIteration(it, i, results + (i - begin));
+            advance(it, 1);
+        }
+        return true;
+    }
+};
+template <typename Iterator, typename Functor>
+inline ThreadEngineStarter<void> startMap(Iterator begin, Iterator end, Functor functor)
+{
+    return startThreadEngine(new MapKernel<Iterator, Functor>(begin, end, functor));
+}
+template <typename T, typename Iterator, typename Functor>
+inline ThreadEngineStarter<T> startMapped(Iterator begin, Iterator end, Functor functor)
+{
+    return startThreadEngine(new MappedEachKernel<Iterator, Functor>(begin, end, functor));
+}
+template <typename Sequence, typename Base, typename Functor>
+struct SequenceHolder1 : public Base
+{
+    SequenceHolder1(const Sequence &_sequence, Functor functor)
+        : Base(_sequence.begin(), _sequence.end(), functor), sequence(_sequence)
+    { }
+    Sequence sequence;
+    void finish()
+    {
+        Base::finish();
+        sequence = Sequence();
+    }
+};
+template <typename T, typename Sequence, typename Functor>
+inline ThreadEngineStarter<T> startMapped(const Sequence &sequence, Functor functor)
+{
+    typedef SequenceHolder1<Sequence,
+                            MappedEachKernel<typename Sequence::const_iterator , Functor>, Functor>
+                            SequenceHolderType;
+    return startThreadEngine(new SequenceHolderType(sequence, functor));
+}
+template <typename IntermediateType, typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(const Sequence & sequence,
+                                                           MapFunctor mapFunctor, ReduceFunctor reduceFunctor,
+                                                           ReduceOptions options)
+{
+    typedef typename Sequence::const_iterator Iterator;
+    typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer;
+    typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType;
+    typedef SequenceHolder2<Sequence, MappedReduceType, MapFunctor, ReduceFunctor> SequenceHolderType;
+    return startThreadEngine(new SequenceHolderType(sequence, mapFunctor, reduceFunctor, options));
+}
+template <typename IntermediateType, typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startMappedReduced(Iterator begin, Iterator end,
+                                                           MapFunctor mapFunctor, ReduceFunctor reduceFunctor,
+                                                           ReduceOptions options)
+{
+    typedef ReduceKernel<ReduceFunctor, ResultType, IntermediateType> Reducer;
+    typedef MappedReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> MappedReduceType;
+    return startThreadEngine(new MappedReduceType(begin, end, mapFunctor, reduceFunctor, options));
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T>
+struct qValueType
+{
+    typedef typename T::value_type value_type;
+};
+template <typename T>
+struct qValueType<const T*>
+{
+    typedef T value_type;
+};
+template <typename T>
+struct qValueType<T*>
+{
+    typedef T value_type;
+};
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+class FilterKernel : public IterateKernel<typename Sequence::const_iterator, void>
+{
+    typedef ReduceKernel<ReduceFunctor, Sequence, typename Sequence::value_type> Reducer;
+    typedef IterateKernel<typename Sequence::const_iterator, void> IterateKernelType;
+    typedef typename ReduceFunctor::result_type T;
+    Sequence reducedResult;
+    Sequence &sequence;
+    KeepFunctor keep;
+    ReduceFunctor reduce;
+    Reducer reducer;
+public:
+    FilterKernel(Sequence &_sequence, KeepFunctor _keep, ReduceFunctor _reduce)
+        : IterateKernelType(const_cast<const Sequence &>(_sequence).begin(), const_cast<const Sequence &>(_sequence).end()), reducedResult(),
+          sequence(_sequence),
+          keep(_keep),
+          reduce(_reduce),
+          reducer(OrderedReduce)
+    { }
+    bool runIteration(typename Sequence::const_iterator it, int index, T *)
+    {
+        IntermediateResults<typename Sequence::value_type> results;
+        results.begin = index;
+        results.end = index + 1;
+            if (keep(*it))
+                results.vector.append(*it);
+            reducer.runReduce(reduce, reducedResult, results);
+            return false;
+    }
+    bool runIterations(typename Sequence::const_iterator sequenceBeginIterator, int begin, int end, T *)
+    {
+        IntermediateResults<typename Sequence::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(end - begin);
+        typename Sequence::const_iterator it = sequenceBeginIterator;
+        advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (keep(*it))
+                results.vector.append(*it);
+            advance(it, 1);
+        }
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+    void finish()
+    {
+        reducer.finish(reduce, reducedResult);
+        sequence = reducedResult;
+    }
+    inline bool shouldThrottleThread()
+    {
+        return IterateKernelType::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+    inline bool shouldStartThread()
+    {
+        return IterateKernelType::shouldStartThread() && reducer.shouldStartThread();
+    }
+    typedef void ReturnType;
+    typedef void ResultType;
+};
+template <typename ReducedResultType,
+          typename Iterator,
+          typename KeepFunctor,
+          typename ReduceFunctor,
+          typename Reducer = ReduceKernel<ReduceFunctor,
+                                          ReducedResultType,
+                                          typename qValueType<Iterator>::value_type> >
+class FilteredReducedKernel : public IterateKernel<Iterator, ReducedResultType>
+{
+    ReducedResultType reducedResult;
+    KeepFunctor keep;
+    ReduceFunctor reduce;
+    Reducer reducer;
+    typedef IterateKernel<Iterator, ReducedResultType> IterateKernelType;
+public:
+    FilteredReducedKernel(Iterator begin,
+                          Iterator end,
+                          KeepFunctor _keep,
+                          ReduceFunctor _reduce,
+                          ReduceOptions reduceOption)
+        : IterateKernelType(begin, end), reducedResult(), keep(_keep), reduce(_reduce), reducer(reduceOption)
+    { }
+    bool runIteration(Iterator it, int index, ReducedResultType *)
+    {
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = index;
+        results.end = index + 1;
+        if (keep(*it))
+            results.vector.append(*it);
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, ReducedResultType *)
+    {
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(end - begin);
+        Iterator it = sequenceBeginIterator;
+        advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (keep(*it))
+                results.vector.append(*it);
+            advance(it, 1);
+        }
+        reducer.runReduce(reduce, reducedResult, results);
+        return false;
+    }
+    void finish()
+    {
+        reducer.finish(reduce, reducedResult);
+    }
+    inline bool shouldThrottleThread()
+    {
+        return IterateKernelType::shouldThrottleThread() || reducer.shouldThrottle();
+    }
+    inline bool shouldStartThread()
+    {
+        return IterateKernelType::shouldStartThread() && reducer.shouldStartThread();
+    }
+    typedef ReducedResultType ReturnType;
+    typedef ReducedResultType ResultType;
+    ReducedResultType *result()
+    {
+        return &reducedResult;
+    }
+};
+template <typename Iterator, typename KeepFunctor>
+class FilteredEachKernel : public IterateKernel<Iterator, typename qValueType<Iterator>::value_type>
+{
+    typedef typename qValueType<Iterator>::value_type T;
+    typedef IterateKernel<Iterator, T> IterateKernelType;
+    KeepFunctor keep;
+public:
+    typedef T ReturnType;
+    typedef T ResultType;
+    FilteredEachKernel(Iterator begin, Iterator end, KeepFunctor _keep)
+        : IterateKernelType(begin, end), keep(_keep)
+    { }
+    void start()
+    {
+        if (this->futureInterface)
+            this->futureInterface->setFilterMode(true);
+        IterateKernelType::start();
+    }
+    bool runIteration(Iterator it, int index, T *)
+    {
+        if (keep(*it))
+            this->reportResult(&(*it), index);
+        else
+            this->reportResult(0, index);
+        return false;
+    }
+    bool runIterations(Iterator sequenceBeginIterator, int begin, int end, T *)
+    {
+        const int count = end - begin;
+        IntermediateResults<typename qValueType<Iterator>::value_type> results;
+        results.begin = begin;
+        results.end = end;
+        results.vector.reserve(count);
+        Iterator it = sequenceBeginIterator;
+        advance(it, begin);
+        for (int i = begin; i < end; ++i) {
+            if (keep(*it))
+                results.vector.append(*it);
+            advance(it, 1);
+        }
+        this->reportResults(results.vector, begin, count);
+        return false;
+    }
+};
+template <typename Iterator, typename KeepFunctor>
+inline
+ThreadEngineStarter<typename qValueType<Iterator>::value_type>
+startFiltered(Iterator begin, Iterator end, KeepFunctor functor)
+{
+    return startThreadEngine(new FilteredEachKernel<Iterator, KeepFunctor>(begin, end, functor));
+}
+template <typename Sequence, typename KeepFunctor>
+inline ThreadEngineStarter<typename Sequence::value_type>
+startFiltered(const Sequence &sequence, KeepFunctor functor)
+{
+    typedef SequenceHolder1<Sequence,
+                            FilteredEachKernel<typename Sequence::const_iterator, KeepFunctor>,
+                            KeepFunctor>
+        SequenceHolderType;
+        return startThreadEngine(new SequenceHolderType(sequence, functor));
+}
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(const Sequence & sequence,
+                                                           MapFunctor mapFunctor, ReduceFunctor reduceFunctor,
+                                                           ReduceOptions options)
+{
+    typedef typename Sequence::const_iterator Iterator;
+    typedef ReduceKernel<ReduceFunctor, ResultType, typename qValueType<Iterator>::value_type > Reducer;
+    typedef FilteredReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> FilteredReduceType;
+    typedef SequenceHolder2<Sequence, FilteredReduceType, MapFunctor, ReduceFunctor> SequenceHolderType;
+    return startThreadEngine(new SequenceHolderType(sequence, mapFunctor, reduceFunctor, options));
+}
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+inline ThreadEngineStarter<ResultType> startFilteredReduced(Iterator begin, Iterator end,
+                                                           MapFunctor mapFunctor, ReduceFunctor reduceFunctor,
+                                                           ReduceOptions options)
+{
+    typedef ReduceKernel<ReduceFunctor, ResultType, typename qValueType<Iterator>::value_type> Reducer;
+    typedef FilteredReducedKernel<ResultType, Iterator, MapFunctor, ReduceFunctor, Reducer> FilteredReduceType;
+    return startThreadEngine(new FilteredReduceType(begin, end, mapFunctor, reduceFunctor, options));
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T>
+class FunctionWrapper0
+{
+public:
+    typedef T (*FunctionPointerType)();
+    typedef T result_type;
+    inline FunctionWrapper0(FunctionPointerType _functionPointer)
+    :functionPointer(_functionPointer) { }
+    inline T operator()()
+    {
+        return functionPointer();
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+template <typename T, typename U>
+class FunctionWrapper1
+{
+public:
+    typedef T (*FunctionPointerType)(U u);
+    typedef T result_type;
+    inline FunctionWrapper1(FunctionPointerType _functionPointer)
+    :functionPointer(_functionPointer) { }
+    inline T operator()(U u)
+    {
+        return functionPointer(u);
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+template <typename T, typename U, typename V>
+class FunctionWrapper2
+{
+public:
+    typedef T (*FunctionPointerType)(U u, V v);
+    typedef T result_type;
+    inline FunctionWrapper2(FunctionPointerType _functionPointer)
+    :functionPointer(_functionPointer) { }
+    inline T operator()(U u, V v)
+    {
+        return functionPointer(u, v);
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+template <typename T, typename C>
+class MemberFunctionWrapper
+{
+public:
+    typedef T (C::*FunctionPointerType)();
+    typedef T result_type;
+    inline MemberFunctionWrapper(FunctionPointerType _functionPointer)
+    :functionPointer(_functionPointer) { }
+    inline T operator()(C &c)
+    {
+        return (c.*functionPointer)();
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+template <typename T, typename C, typename U>
+class MemberFunctionWrapper1
+{
+public:
+    typedef T (C::*FunctionPointerType)(U);
+    typedef T result_type;
+    inline MemberFunctionWrapper1(FunctionPointerType _functionPointer)
+        : functionPointer(_functionPointer)
+    { }
+    inline T operator()(C &c, U u)
+    {
+        return (c.*functionPointer)(u);
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+template <typename T, typename C>
+class ConstMemberFunctionWrapper
+{
+public:
+    typedef T (C::*FunctionPointerType)() const;
+    typedef T result_type;
+    inline ConstMemberFunctionWrapper(FunctionPointerType _functionPointer)
+    :functionPointer(_functionPointer) { }
+    inline T operator()(const C &c) const
+    {
+        return (c.*functionPointer)();
+    }
+private:
+    FunctionPointerType functionPointer;
+};
+}
+namespace QtPrivate {
+template <typename T>
+const T& createFunctionWrapper(const T& t)
+{
+    return t;
+}
+template <typename T, typename U>
+QtConcurrent::FunctionWrapper1<T, U> createFunctionWrapper(T (*func)(U))
+{
+    return QtConcurrent::FunctionWrapper1<T, U>(func);
+}
+template <typename T, typename C>
+QtConcurrent::MemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)())
+{
+    return QtConcurrent::MemberFunctionWrapper<T, C>(func);
+}
+template <typename T, typename C, typename U>
+QtConcurrent::MemberFunctionWrapper1<T, C, U> createFunctionWrapper(T (C::*func)(U))
+{
+    return QtConcurrent::MemberFunctionWrapper1<T, C, U>(func);
+}
+template <typename T, typename C>
+QtConcurrent::ConstMemberFunctionWrapper<T, C> createFunctionWrapper(T (C::*func)() const)
+{
+    return QtConcurrent::ConstMemberFunctionWrapper<T, C>(func);
+}
+struct PushBackWrapper
+{
+    typedef void result_type;
+    template <class C, class U>
+    inline void operator()(C &c, const U &u) const
+    {
+        return c.push_back(u);
+    }
+};
+template <typename Functor, bool foo = HasResultType<Functor>::Value>
+struct LazyResultType { typedef typename Functor::result_type Type; };
+template <typename Functor>
+struct LazyResultType<Functor, false> { typedef void Type; };
+template <class T>
+struct ReduceResultType;
+template <class U, class V>
+struct ReduceResultType<void(*)(U&,V)>
+{
+    typedef U ResultType;
+};
+template <class T, class C, class U>
+struct ReduceResultType<T(C::*)(U)>
+{
+    typedef C ResultType;
+};
+template <class InputSequence, class MapFunctor>
+struct MapResultType
+{
+    typedef typename LazyResultType<MapFunctor>::Type ResultType;
+};
+template <class U, class V>
+struct MapResultType<void, U (*)(V)>
+{
+    typedef U ResultType;
+};
+template <class T, class C>
+struct MapResultType<void, T(C::*)() const>
+{
+    typedef T ResultType;
+};
+template <template <typename> class InputSequence, typename MapFunctor, typename T>
+struct MapResultType<InputSequence<T>, MapFunctor>
+{
+    typedef InputSequence<typename LazyResultType<MapFunctor>::Type> ResultType;
+};
+template <template <typename> class InputSequence, class T, class U, class V>
+struct MapResultType<InputSequence<T>, U (*)(V)>
+{
+    typedef InputSequence<U> ResultType;
+};
+template <template <typename> class InputSequence, class T, class U, class C>
+struct MapResultType<InputSequence<T>, U(C::*)() const>
+{
+    typedef InputSequence<U> ResultType;
+};
+template <class MapFunctor>
+struct MapResultType<QStringList, MapFunctor>
+{
+    typedef QList<typename LazyResultType<MapFunctor>::Type> ResultType;
+};
+template <class U, class V>
+struct MapResultType<QStringList, U (*)(V)>
+{
+    typedef QList<U> ResultType;
+};
+template <class U, class C>
+struct MapResultType<QStringList, U(C::*)() const>
+{
+    typedef QList<U> ResultType;
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ThreadEngineStarter<void> filterInternal(Sequence &sequence, KeepFunctor keep, ReduceFunctor reduce)
+{
+    typedef typename Sequence::const_iterator Iterator;
+    typedef FilterKernel<Sequence, KeepFunctor, ReduceFunctor> KernelType;
+    return startThreadEngine(new KernelType(sequence, keep, reduce));
+}
+template <typename Sequence, typename KeepFunctor>
+QFuture<void> filter(Sequence &sequence, KeepFunctor keep)
+{
+    return filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper());
+}
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(const Sequence &sequence,
+                                    KeepFunctor keep,
+                                    ReduceFunctor reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
+}
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(const Sequence &sequence,
+                                    KeepFunctor keep,
+                                    ReduceFunctor reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+            (sequence,
+             QtPrivate::createFunctionWrapper(keep),
+             QtPrivate::createFunctionWrapper(reduce),
+             options);
+}
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+QFuture<ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor keep,
+                                    ReduceFunctor reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+   return startFilteredReduced<ResultType>(begin, end, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options);
+}
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> filteredReduced(Iterator begin,
+                                    Iterator end,
+                                    KeepFunctor keep,
+                                    ReduceFunctor reduce,
+                                    ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+   return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+           (begin, end,
+            QtPrivate::createFunctionWrapper(keep),
+            QtPrivate::createFunctionWrapper(reduce),
+            options);
+}
+template <typename Sequence, typename KeepFunctor>
+QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, KeepFunctor keep)
+{
+    return startFiltered(sequence, QtPrivate::createFunctionWrapper(keep));
+}
+template <typename Iterator, typename KeepFunctor>
+QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, KeepFunctor keep)
+{
+    return startFiltered(begin, end, QtPrivate::createFunctionWrapper(keep));
+}
+template <typename Sequence, typename KeepFunctor>
+void blockingFilter(Sequence &sequence, KeepFunctor keep)
+{
+    filterInternal(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper()).startBlocking();
+}
+template <typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(const Sequence &sequence,
+                                   KeepFunctor keep,
+                                   ReduceFunctor reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::createFunctionWrapper(reduce), options)
+        .startBlocking();
+}
+template <typename Sequence, typename KeepFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(const Sequence &sequence,
+                                   KeepFunctor keep,
+                                   ReduceFunctor reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return blockingFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
+}
+template <typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor keep,
+                                   ReduceFunctor reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startFilteredReduced<ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename Iterator, typename KeepFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingFilteredReduced(Iterator begin,
+                                   Iterator end,
+                                   KeepFunctor keep,
+                                   ReduceFunctor reduce,
+                                   ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startFilteredReduced<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(keep),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename Sequence, typename KeepFunctor>
+Sequence blockingFiltered(const Sequence &sequence, KeepFunctor keep)
+{
+    return startFilteredReduced<Sequence>(sequence, QtPrivate::createFunctionWrapper(keep), QtPrivate::PushBackWrapper(), OrderedReduce).startBlocking();
+}
+template <typename OutputSequence, typename Iterator, typename KeepFunctor>
+OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor keep)
+{
+    return startFilteredReduced<OutputSequence>(begin, end,
+        QtPrivate::createFunctionWrapper(keep),
+        QtPrivate::PushBackWrapper(),
+        OrderedReduce).startBlocking();
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename Sequence, typename MapFunctor>
+QFuture<void> map(Sequence &sequence, MapFunctor map)
+{
+    return startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map));
+}
+template <typename Iterator, typename MapFunctor>
+QFuture<void> map(Iterator begin, Iterator end, MapFunctor map)
+{
+    return startMap(begin, end, QtPrivate::createFunctionWrapper(map));
+}
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
+}
+template <typename Sequence, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(const Sequence &sequence,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
+}
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
+}
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+QFuture<typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType> mappedReduced(Iterator begin,
+                                  Iterator end,
+                                  MapFunctor map,
+                                  ReduceFunctor reduce,
+                                  ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options);
+}
+template <typename Sequence, typename MapFunctor>
+QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor map)
+{
+    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(sequence, QtPrivate::createFunctionWrapper(map));
+}
+template <typename Iterator, typename MapFunctor>
+QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor map)
+{
+    return startMapped<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType>(begin, end, QtPrivate::createFunctionWrapper(map));
+}
+template <typename Sequence, typename MapFunctor>
+void blockingMap(Sequence &sequence, MapFunctor map)
+{
+    startMap(sequence.begin(), sequence.end(), QtPrivate::createFunctionWrapper(map)).startBlocking();
+}
+template <typename Iterator, typename MapFunctor>
+void blockingMap(Iterator begin, Iterator end, MapFunctor map)
+{
+    startMap(begin, end, QtPrivate::createFunctionWrapper(map)).startBlocking();
+}
+template <typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename MapFunctor, typename ReduceFunctor, typename Sequence>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(const Sequence &sequence,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 ReduceOptions options = ReduceOptions(UnorderedReduce | SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor>
+ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename Iterator, typename MapFunctor, typename ReduceFunctor>
+typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType blockingMappedReduced(Iterator begin,
+                                 Iterator end,
+                                 MapFunctor map,
+                                 ReduceFunctor reduce,
+                                 QtConcurrent::ReduceOptions options = QtConcurrent::ReduceOptions(QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce))
+{
+    return QtConcurrent::startMappedReduced<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType, typename QtPrivate::ReduceResultType<ReduceFunctor>::ResultType>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::createFunctionWrapper(reduce),
+         options)
+        .startBlocking();
+}
+template <typename OutputSequence, typename InputSequence, typename MapFunctor>
+OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor map)
+{
+    return blockingMappedReduced<OutputSequence>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::PushBackWrapper(),
+         QtConcurrent::OrderedReduce);
+}
+template <typename MapFunctor, typename InputSequence>
+typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType blockingMapped(const InputSequence &sequence, MapFunctor map)
+{
+    typedef typename QtPrivate::MapResultType<InputSequence, MapFunctor>::ResultType OutputSequence;
+    return blockingMappedReduced<OutputSequence>
+        (sequence,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::PushBackWrapper(),
+         QtConcurrent::OrderedReduce);
+}
+template <typename Sequence, typename Iterator, typename MapFunctor>
+Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor map)
+{
+    return blockingMappedReduced<Sequence>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::PushBackWrapper(),
+         QtConcurrent::OrderedReduce);
+}
+template <typename Iterator, typename MapFunctor>
+typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType blockingMapped(Iterator begin, Iterator end, MapFunctor map)
+{
+    typedef typename QtPrivate::MapResultType<Iterator, MapFunctor>::ResultType OutputSequence;
+    return blockingMappedReduced<OutputSequence>
+        (begin, end,
+         QtPrivate::createFunctionWrapper(map),
+         QtPrivate::PushBackWrapper(),
+         QtConcurrent::OrderedReduce);
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T>
+struct SelectSpecialization
+{
+    template <class Normal, class Void>
+    struct Type { typedef Normal type; };
+};
+template <>
+struct SelectSpecialization<void>
+{
+    template <class Normal, class Void>
+    struct Type { typedef Void type; };
+};
+template <typename T>
+class RunFunctionTaskBase : public QFutureInterface<T> , public QRunnable
+{
+public:
+    QFuture<T> start()
+    {
+        this->setRunnable(this);
+        this->reportStarted();
+        QFuture<T> future = this->future();
+        QThreadPool::globalInstance()->start(this, 0);
+        return future;
+    }
+    void run() {}
+    virtual void runFunctor() = 0;
+};
+template <typename T>
+class RunFunctionTask : public RunFunctionTaskBase<T>
+{
+public:
+    void run()
+    {
+        if (this->isCanceled()) {
+            this->reportFinished();
+            return;
+        }
+        try {
+            this->runFunctor();
+        } catch (QtConcurrent::Exception &e) {
+            QFutureInterface<T>::reportException(e);
+        } catch (...) {
+            QFutureInterface<T>::reportException(QtConcurrent::UnhandledException());
+        }
+        this->reportResult(result);
+        this->reportFinished();
+    }
+    T result;
+};
+template <>
+class RunFunctionTask<void> : public RunFunctionTaskBase<void>
+{
+public:
+    void run()
+    {
+        if (this->isCanceled()) {
+            this->reportFinished();
+            return;
+        }
+        try {
+            this->runFunctor();
+        } catch (QtConcurrent::Exception &e) {
+            QFutureInterface<void>::reportException(e);
+        } catch (...) {
+            QFutureInterface<void>::reportException(QtConcurrent::UnhandledException());
+        }
+        this->reportFinished();
+    }
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T, typename FunctionPointer>
+struct StoredFunctorCall0: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall0(FunctionPointer _function)
+      : function(_function) {}
+    void runFunctor() { this->result = function(); }
+    FunctionPointer function;
+};
+template <typename FunctionPointer>
+struct StoredFunctorCall0<void, FunctionPointer>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall0(FunctionPointer _function)
+      : function(_function) {}
+    void runFunctor() { function(); }
+    FunctionPointer function;
+};
+template <typename T, typename FunctionPointer>
+struct StoredFunctorPointerCall0: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall0(FunctionPointer * _function)
+      : function(_function) {}
+    void runFunctor() { this->result =(*function)(); }
+    FunctionPointer * function;
+};
+template <typename T, typename FunctionPointer>
+struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
+      : function(_function) {}
+    void runFunctor() {(*function)(); }
+    FunctionPointer * function;
+};
+template <typename T, typename FunctionPointer>
+struct SelectStoredFunctorPointerCall0
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall0 <T, FunctionPointer>,
+             VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
+};
+template <typename T, typename Class>
+class StoredMemberFunctionCall0 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)();
+    }
+private:
+    T (Class::*fn)();
+    Class object;
+};
+template <typename T, typename Class>
+class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        (object.*fn)();
+    }
+private:
+    T (Class::*fn)();
+    Class object;
+};
+template <typename T, typename Class>
+struct SelectStoredMemberFunctionCall0
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall0 <T, Class>,
+             VoidStoredMemberFunctionCall0<T, Class> >::type type;
+};
+template <typename T, typename Class>
+class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)();
+    }
+private:
+    T (Class::*fn)()const;
+    const Class object;
+};
+template <typename T, typename Class>
+class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        (object.*fn)();
+    }
+private:
+    T (Class::*fn)()const;
+    const Class object;
+};
+template <typename T, typename Class>
+struct SelectStoredConstMemberFunctionCall0
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall0 <T, Class>,
+             VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
+};
+template <typename T, typename Class>
+class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)();
+    }
+private:
+    T (Class::*fn)();
+    Class *object;
+};
+template <typename T, typename Class>
+class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        (object->*fn)();
+    }
+private:
+    T (Class::*fn)();
+    Class *object;
+};
+template <typename T, typename Class>
+struct SelectStoredMemberFunctionPointerCall0
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall0 <T, Class>,
+             VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
+};
+template <typename T, typename Class>
+class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)();
+    }
+private:
+    T (Class::*fn)()const;
+    Class const *object;
+};
+template <typename T, typename Class>
+class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
+    : fn(_fn), object(_object){ }
+    void runFunctor()
+    {
+        (object->*fn)();
+    }
+private:
+    T (Class::*fn)()const;
+    Class const *object;
+};
+template <typename T, typename Class>
+struct SelectStoredConstMemberFunctionPointerCall0
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall0 <T, Class>,
+             VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type;
+};
+template <typename T, typename FunctionPointer, typename Arg1>
+struct StoredFunctorCall1: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
+      : function(_function), arg1(_arg1) {}
+    void runFunctor() { this->result = function(arg1); }
+    FunctionPointer function;
+    Arg1 arg1;
+};
+template <typename FunctionPointer, typename Arg1>
+struct StoredFunctorCall1<void, FunctionPointer, Arg1>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
+      : function(_function), arg1(_arg1) {}
+    void runFunctor() { function(arg1); }
+    FunctionPointer function;
+    Arg1 arg1;
+};
+template <typename T, typename FunctionPointer, typename Arg1>
+struct StoredFunctorPointerCall1: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
+      : function(_function), arg1(_arg1) {}
+    void runFunctor() { this->result =(*function)(arg1); }
+    FunctionPointer * function;
+    Arg1 arg1;
+};
+template <typename T, typename FunctionPointer, typename Arg1>
+struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
+      : function(_function), arg1(_arg1) {}
+    void runFunctor() {(*function)(arg1); }
+    FunctionPointer * function;
+    Arg1 arg1;
+};
+template <typename T, typename FunctionPointer, typename Arg1>
+struct SelectStoredFunctorPointerCall1
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall1 <T, FunctionPointer, Arg1>,
+             VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class StoredMemberFunctionCall1 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1);
+    Class object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1);
+    Class object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+struct SelectStoredMemberFunctionCall1
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall1 <T, Class, Param1, Arg1>,
+             VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1)const;
+    const Class object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1)const;
+    const Class object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+struct SelectStoredConstMemberFunctionCall1
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall1 <T, Class, Param1, Arg1>,
+             VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1);
+    Class *object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1);
+    Class *object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+struct SelectStoredMemberFunctionPointerCall1
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
+             VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1)const;
+    Class const *object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
+    : fn(_fn), object(_object), arg1(_arg1){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1);
+    }
+private:
+    T (Class::*fn)(Param1)const;
+    Class const *object;
+    Arg1 arg1;
+};
+template <typename T, typename Class, typename Param1, typename Arg1>
+struct SelectStoredConstMemberFunctionPointerCall1
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall1 <T, Class, Param1, Arg1>,
+             VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
+struct StoredFunctorCall2: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
+      : function(_function), arg1(_arg1), arg2(_arg2) {}
+    void runFunctor() { this->result = function(arg1, arg2); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename FunctionPointer, typename Arg1, typename Arg2>
+struct StoredFunctorCall2<void, FunctionPointer, Arg1, Arg2>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
+      : function(_function), arg1(_arg1), arg2(_arg2) {}
+    void runFunctor() { function(arg1, arg2); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
+struct StoredFunctorPointerCall2: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
+      : function(_function), arg1(_arg1), arg2(_arg2) {}
+    void runFunctor() { this->result =(*function)(arg1, arg2); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
+struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
+    : function(_function), arg1(_arg1), arg2(_arg2) {}
+    void runFunctor() {(*function)(arg1, arg2); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
+struct SelectStoredFunctorPointerCall2
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall2 <T, FunctionPointer, Arg1, Arg2>,
+             VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class StoredMemberFunctionCall2 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2);
+    Class object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2);
+    Class object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+struct SelectStoredMemberFunctionCall2
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
+             VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+struct SelectStoredConstMemberFunctionCall2
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
+             VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2);
+    Class *object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2);
+    Class *object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+struct SelectStoredMemberFunctionPointerCall2
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
+             VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2);
+    }
+private:
+    T (Class::*fn)(Param1, Param2)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+struct SelectStoredConstMemberFunctionPointerCall2
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall2 <T, Class, Param1, Arg1, Param2, Arg2>,
+             VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
+struct StoredFunctorCall3: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
+    void runFunctor() { this->result = function(arg1, arg2, arg3); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
+struct StoredFunctorCall3<void, FunctionPointer, Arg1, Arg2, Arg3>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
+    void runFunctor() { function(arg1, arg2, arg3); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
+struct StoredFunctorPointerCall3: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
+    void runFunctor() { this->result =(*function)(arg1, arg2, arg3); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
+struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
+    void runFunctor() {(*function)(arg1, arg2, arg3); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
+struct SelectStoredFunctorPointerCall3
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall3 <T, FunctionPointer, Arg1, Arg2, Arg3>,
+             VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class StoredMemberFunctionCall3 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+struct SelectStoredMemberFunctionCall3
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
+             VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+struct SelectStoredConstMemberFunctionCall3
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
+             VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+struct SelectStoredMemberFunctionPointerCall3
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
+             VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+struct SelectStoredConstMemberFunctionPointerCall3
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall3 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
+             VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct StoredFunctorCall4: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
+    void runFunctor() { this->result = function(arg1, arg2, arg3, arg4); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct StoredFunctorCall4<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
+    void runFunctor() { function(arg1, arg2, arg3, arg4); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct StoredFunctorPointerCall4: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
+    void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
+    void runFunctor() {(*function)(arg1, arg2, arg3, arg4); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+struct SelectStoredFunctorPointerCall4
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall4 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
+             VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class StoredMemberFunctionCall4 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+struct SelectStoredMemberFunctionCall4
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
+             VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+struct SelectStoredConstMemberFunctionCall4
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
+             VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+struct SelectStoredMemberFunctionPointerCall4
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
+             VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3, arg4);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+struct SelectStoredConstMemberFunctionPointerCall4
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall4 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
+             VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct StoredFunctorCall5: public RunFunctionTask<T>
+{
+    inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
+    void runFunctor() { this->result = function(arg1, arg2, arg3, arg4, arg5); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct StoredFunctorCall5<void, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>: public RunFunctionTask<void>
+{
+    inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
+    void runFunctor() { function(arg1, arg2, arg3, arg4, arg5); }
+    FunctionPointer function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct StoredFunctorPointerCall5: public RunFunctionTask<T>
+{
+    inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
+    void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
+{
+    inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
+    void runFunctor() {(*function)(arg1, arg2, arg3, arg4, arg5); }
+    FunctionPointer * function;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+struct SelectStoredFunctorPointerCall5
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredFunctorPointerCall5 <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
+             VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class StoredMemberFunctionCall5 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
+    Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+struct SelectStoredMemberFunctionCall5
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
+             VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    const Class object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+struct SelectStoredConstMemberFunctionCall5
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
+             VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
+{
+public:
+    StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
+    Class *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+struct SelectStoredMemberFunctionPointerCall5
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
+             VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
+{
+public:
+    StoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
+{
+public:
+    VoidStoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
+    void runFunctor()
+    {
+        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
+    }
+private:
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    Class const *object;
+    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
+};
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+struct SelectStoredConstMemberFunctionPointerCall5
+{
+    typedef typename SelectSpecialization<T>::template
+        Type<StoredConstMemberFunctionPointerCall5 <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
+             VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
+};
+template <typename T, typename Functor>
+class StoredFunctorCall : public RunFunctionTask<T>
+{
+public:
+    StoredFunctorCall(const Functor &f) : functor(f) { }
+    void runFunctor()
+    {
+        this->result = functor();
+    }
+private:
+    Functor functor;
+};
+template <typename Functor>
+class StoredFunctorCall<void, Functor> : public RunFunctionTask<void>
+{
+public:
+    StoredFunctorCall(const Functor &f) : functor(f) { }
+    void runFunctor()
+    {
+        functor();
+    }
+private:
+    Functor functor;
+};
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+namespace QtConcurrent {
+template <typename T>
+QFuture<T> run(T (*functionPointer)())
+{
+    return (new StoredFunctorCall0<T, T (*)()>(functionPointer))->start();
+}
+template <typename T, typename Param1, typename Arg1>
+QFuture<T> run(T (*functionPointer)(Param1), const Arg1 &arg1)
+{
+    return (new StoredFunctorCall1<T, T (*)(Param1), Arg1>(functionPointer, arg1))->start();
+}
+template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2>
+QFuture<T> run(T (*functionPointer)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new StoredFunctorCall2<T, T (*)(Param1, Param2), Arg1, Arg2>(functionPointer, arg1, arg2))->start();
+}
+template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new StoredFunctorCall3<T, T (*)(Param1, Param2, Param3), Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start();
+}
+template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new StoredFunctorCall4<T, T (*)(Param1, Param2, Param3, Param4), Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start();
+}
+template <typename T, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+QFuture<T> run(T (*functionPointer)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new StoredFunctorCall5<T, T (*)(Param1, Param2, Param3, Param4, Param5), Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename FunctionObject>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject)
+{
+    return (new StoredFunctorCall0<typename FunctionObject::result_type, FunctionObject>(functionObject))->start();
+}
+template <typename FunctionObject, typename Arg1>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1)
+{
+    return (new StoredFunctorCall1<typename FunctionObject::result_type, FunctionObject, Arg1>(functionObject, arg1))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new StoredFunctorCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>(functionObject, arg1, arg2))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new StoredFunctorCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>(functionObject, arg1, arg2, arg3))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new StoredFunctorCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>(functionObject, arg1, arg2, arg3, arg4))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+QFuture<typename FunctionObject::result_type> run(FunctionObject functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new StoredFunctorCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename FunctionObject>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject)
+{
+    return (new typename SelectStoredFunctorPointerCall0<typename FunctionObject::result_type, FunctionObject>::type(functionObject))->start();
+}
+template <typename FunctionObject, typename Arg1>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1)
+{
+    return (new typename SelectStoredFunctorPointerCall1<typename FunctionObject::result_type, FunctionObject, Arg1>::type(functionObject, arg1))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new typename SelectStoredFunctorPointerCall2<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2>::type(functionObject, arg1, arg2))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new typename SelectStoredFunctorPointerCall3<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3>::type(functionObject, arg1, arg2, arg3))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new typename SelectStoredFunctorPointerCall4<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4>::type(functionObject, arg1, arg2, arg3, arg4))->start();
+}
+template <typename FunctionObject, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
+QFuture<typename FunctionObject::result_type> run(FunctionObject *functionObject, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new typename SelectStoredFunctorPointerCall5<typename FunctionObject::result_type, FunctionObject, Arg1, Arg2, Arg3, Arg4, Arg5>::type(functionObject, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename T, typename Class>
+QFuture<T> run(const Class &object, T (Class::*fn)())
+{
+    return (new typename SelectStoredMemberFunctionCall0<T, Class>::type(fn, object))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1), const Arg1 &arg1)
+{
+    return (new typename SelectStoredMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new typename SelectStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new typename SelectStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new typename SelectStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new typename SelectStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename T, typename Class>
+QFuture<T> run(const Class &object, T (Class::*fn)() const)
+{
+    return (new typename SelectStoredConstMemberFunctionCall0<T, Class>::type(fn, object))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
+{
+    return (new typename SelectStoredConstMemberFunctionCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new typename SelectStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new typename SelectStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new typename SelectStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+QFuture<T> run(const Class &object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new typename SelectStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename T, typename Class>
+QFuture<T> run(Class *object, T (Class::*fn)())
+{
+    return (new typename SelectStoredMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1>
+QFuture<T> run(Class *object, T (Class::*fn)(Param1), const Arg1 &arg1)
+{
+    return (new typename SelectStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2), const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new typename SelectStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new typename SelectStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new typename SelectStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+QFuture<T> run(Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5), const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new typename SelectStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
+}
+template <typename T, typename Class>
+QFuture<T> run(const Class *object, T (Class::*fn)() const)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall0<T, Class>::type(fn, object))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1>
+QFuture<T> run(const Class *object, T (Class::*fn)(Param1) const, const Arg1 &arg1)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1>::type(fn, object, arg1))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
+QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2) const, const Arg1 &arg1, const Arg2 &arg2)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2>::type(fn, object, arg1, arg2))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
+QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>::type(fn, object, arg1, arg2, arg3))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
+QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>::type(fn, object, arg1, arg2, arg3, arg4))->start();
+}
+template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
+QFuture<T> run(const Class *object, T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const, const Arg1 &arg1, const Arg2 &arg2, const Arg3 &arg3, const Arg4 &arg4, const Arg5 &arg5)
+{
+    return (new typename SelectStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>::type(fn, object, arg1, arg2, arg3, arg4, arg5))->start();
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLibraryPrivate;
+class QLibrary : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum LoadHint {
+        ResolveAllSymbolsHint = 0x01,
+        ExportExternalSymbolsHint = 0x02,
+        LoadArchiveMemberHint = 0x04,
+        ImprovedSearchHeuristics = 0x08
+    };
+    typedef QFlags<LoadHint> LoadHints;
+    explicit QLibrary(QObject *parent = 0);
+    explicit QLibrary(const QString& fileName, QObject *parent = 0);
+    explicit QLibrary(const QString& fileName, int verNum, QObject *parent = 0);
+    explicit QLibrary(const QString& fileName, const QString &version, QObject *parent = 0);
+    ~QLibrary();
+    void *resolve(const char *symbol);
+    static void *resolve(const QString &fileName, const char *symbol);
+    static void *resolve(const QString &fileName, int verNum, const char *symbol);
+    static void *resolve(const QString &fileName, const QString &version, const char *symbol);
+    bool load();
+    bool unload();
+    bool isLoaded() const;
+    static bool isLibrary(const QString &fileName);
+    void setFileName(const QString &fileName);
+    QString fileName() const;
+    void setFileNameAndVersion(const QString &fileName, int verNum);
+    void setFileNameAndVersion(const QString &fileName, const QString &version);
+    QString errorString() const;
+    void setLoadHints(LoadHints hints);
+    LoadHints loadHints() const;
+private:
+    QLibraryPrivate *d;
+    bool did_load;
+    QLibrary(const QLibrary &); QLibrary &operator=(const QLibrary &);
+};
+ inline QFlags<QLibrary::LoadHints::enum_type> operator|(QLibrary::LoadHints::enum_type f1, QLibrary::LoadHints::enum_type f2) { return QFlags<QLibrary::LoadHints::enum_type>(f1) | f2; } inline QFlags<QLibrary::LoadHints::enum_type> operator|(QLibrary::LoadHints::enum_type f1, QFlags<QLibrary::LoadHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QLibrary::LoadHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLibraryPrivate;
+class QPluginLoader : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QPluginLoader(QObject *parent = 0);
+    explicit QPluginLoader(const QString &fileName, QObject *parent = 0);
+    ~QPluginLoader();
+    QObject *instance();
+    static QObjectList staticInstances();
+    bool load();
+    bool unload();
+    bool isLoaded() const;
+    void setFileName(const QString &fileName);
+    QString fileName() const;
+    QString errorString() const;
+    void setLoadHints(QLibrary::LoadHints loadHints);
+    QLibrary::LoadHints loadHints() const;
+private:
+    QLibraryPrivate *d;
+    bool did_load;
+    QPluginLoader(const QPluginLoader &); QPluginLoader &operator=(const QPluginLoader &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QUuid
+{
+    enum Variant {
+        VarUnknown =-1,
+        NCS = 0,
+        DCE = 2,
+        Microsoft = 6,
+        Reserved = 7
+    };
+    enum Version {
+        VerUnknown =-1,
+        Time = 1,
+        EmbeddedPOSIX = 2,
+        Name = 3,
+        Random = 4
+    };
+    QUuid()
+    {
+        data1 = 0;
+        data2 = 0;
+        data3 = 0;
+        for(int i = 0; i < 8; i++)
+            data4[i] = 0;
+    }
+    QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8)
+    {
+        data1 = l;
+        data2 = w1;
+        data3 = w2;
+        data4[0] = b1;
+        data4[1] = b2;
+        data4[2] = b3;
+        data4[3] = b4;
+        data4[4] = b5;
+        data4[5] = b6;
+        data4[6] = b7;
+        data4[7] = b8;
+    }
+    QUuid(const QString &);
+    QUuid(const char *);
+    QString toString() const;
+    operator QString() const { return toString(); }
+    QUuid(const QByteArray &);
+    QByteArray toByteArray() const;
+    QByteArray toRfc4122() const;
+    static QUuid fromRfc4122(const QByteArray &);
+    bool isNull() const;
+    bool operator==(const QUuid &orig) const
+    {
+        uint i;
+        if (data1 != orig.data1 || data2 != orig.data2 ||
+             data3 != orig.data3)
+            return false;
+        for(i = 0; i < 8; i++)
+            if (data4[i] != orig.data4[i])
+                return false;
+        return true;
+    }
+    bool operator!=(const QUuid &orig) const
+    {
+        return !(*this == orig);
+    }
+    bool operator<(const QUuid &other) const;
+    bool operator>(const QUuid &other) const;
+    static QUuid createUuid();
+    QUuid::Variant variant() const;
+    QUuid::Version version() const;
+    uint data1;
+    ushort data2;
+    ushort data3;
+    uchar data4[8];
+};
+ QDataStream &operator<<(QDataStream &, const QUuid &);
+ QDataStream &operator>>(QDataStream &, QUuid &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAnimationGroup;
+class QSequentialAnimationGroup;
+class QAnimationDriver;
+class QAbstractAnimationPrivate;
+class QAbstractAnimation : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum Direction {
+        Forward,
+        Backward
+    };
+    enum State {
+        Stopped,
+        Paused,
+        Running
+    };
+    enum DeletionPolicy {
+        KeepWhenStopped = 0,
+        DeleteWhenStopped
+    };
+    QAbstractAnimation(QObject *parent = 0);
+    virtual ~QAbstractAnimation();
+    State state() const;
+    QAnimationGroup *group() const;
+    Direction direction() const;
+    void setDirection(Direction direction);
+    int currentTime() const;
+    int currentLoopTime() const;
+    int loopCount() const;
+    void setLoopCount(int loopCount);
+    int currentLoop() const;
+    virtual int duration() const = 0;
+    int totalDuration() const;
+protected:
+    void finished();
+    void stateChanged(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+    void currentLoopChanged(int currentLoop);
+    void directionChanged(QAbstractAnimation::Direction);
+public :
+    void start(QAbstractAnimation::DeletionPolicy policy = KeepWhenStopped);
+    void pause();
+    void resume();
+    void setPaused(bool);
+    void stop();
+    void setCurrentTime(int msecs);
+protected:
+    QAbstractAnimation(QAbstractAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+    virtual void updateCurrentTime(int currentTime) = 0;
+    virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+    virtual void updateDirection(QAbstractAnimation::Direction direction);
+private:
+    QAbstractAnimation(const QAbstractAnimation &); QAbstractAnimation &operator=(const QAbstractAnimation &);
+    inline QAbstractAnimationPrivate* d_func() { return reinterpret_cast<QAbstractAnimationPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractAnimationPrivate* d_func() const { return reinterpret_cast<const QAbstractAnimationPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractAnimationPrivate;
+};
+class QAnimationDriverPrivate;
+class QAnimationDriver : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QAnimationDriverPrivate* d_func() { return reinterpret_cast<QAnimationDriverPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAnimationDriverPrivate* d_func() const { return reinterpret_cast<const QAnimationDriverPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAnimationDriverPrivate;
+public:
+    QAnimationDriver(QObject *parent = 0);
+    void advance();
+    void install();
+    bool isRunning() const;
+protected:
+    virtual void started() {};
+    virtual void stopped() {};
+    QAnimationDriver(QAnimationDriverPrivate &dd, QObject *parent = 0);
+private:
+    friend class QUnifiedTimer;
+    void start();
+    void stop();
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAnimationGroupPrivate;
+class QAnimationGroup : public QAbstractAnimation
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QAnimationGroup(QObject *parent = 0);
+    ~QAnimationGroup();
+    QAbstractAnimation *animationAt(int index) const;
+    int animationCount() const;
+    int indexOfAnimation(QAbstractAnimation *animation) const;
+    void addAnimation(QAbstractAnimation *animation);
+    void insertAnimation(int index, QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QAbstractAnimation *takeAnimation(int index);
+    void clear();
+protected:
+    QAnimationGroup(QAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+private:
+    QAnimationGroup(const QAnimationGroup &); QAnimationGroup &operator=(const QAnimationGroup &);
+    inline QAnimationGroupPrivate* d_func() { return reinterpret_cast<QAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAnimationGroupPrivate* d_func() const { return reinterpret_cast<const QAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAnimationGroupPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QParallelAnimationGroupPrivate;
+class QParallelAnimationGroup : public QAnimationGroup
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QParallelAnimationGroup(QObject *parent = 0);
+    ~QParallelAnimationGroup();
+    int duration() const;
+protected:
+    QParallelAnimationGroup(QParallelAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+    void updateCurrentTime(int currentTime);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+private:
+    QParallelAnimationGroup(const QParallelAnimationGroup &); QParallelAnimationGroup &operator=(const QParallelAnimationGroup &);
+    inline QParallelAnimationGroupPrivate* d_func() { return reinterpret_cast<QParallelAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } inline const QParallelAnimationGroupPrivate* d_func() const { return reinterpret_cast<const QParallelAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } friend class QParallelAnimationGroupPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QPauseAnimationPrivate;
+class QPauseAnimation : public QAbstractAnimation
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QPauseAnimation(QObject *parent = 0);
+    QPauseAnimation(int msecs, QObject *parent = 0);
+    ~QPauseAnimation();
+    int duration() const;
+    void setDuration(int msecs);
+protected:
+    bool event(QEvent *e);
+    void updateCurrentTime(int);
+private:
+    QPauseAnimation(const QPauseAnimation &); QPauseAnimation &operator=(const QPauseAnimation &);
+    inline QPauseAnimationPrivate* d_func() { return reinterpret_cast<QPauseAnimationPrivate *>(qGetPtrHelper(d_ptr)); } inline const QPauseAnimationPrivate* d_func() const { return reinterpret_cast<const QPauseAnimationPrivate *>(qGetPtrHelper(d_ptr)); } friend class QPauseAnimationPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QVariantAnimationPrivate;
+class QVariantAnimation : public QAbstractAnimation
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    typedef QPair<qreal, QVariant> KeyValue;
+    typedef QVector<KeyValue> KeyValues;
+    QVariantAnimation(QObject *parent = 0);
+    ~QVariantAnimation();
+    QVariant startValue() const;
+    void setStartValue(const QVariant &value);
+    QVariant endValue() const;
+    void setEndValue(const QVariant &value);
+    QVariant keyValueAt(qreal step) const;
+    void setKeyValueAt(qreal step, const QVariant &value);
+    KeyValues keyValues() const;
+    void setKeyValues(const KeyValues &values);
+    QVariant currentValue() const;
+    int duration() const;
+    void setDuration(int msecs);
+    QEasingCurve easingCurve() const;
+    void setEasingCurve(const QEasingCurve &easing);
+    typedef QVariant (*Interpolator)(const void *from, const void *to, qreal progress);
+protected:
+    void valueChanged(const QVariant &value);
+protected:
+    QVariantAnimation(QVariantAnimationPrivate &dd, QObject *parent = 0);
+    bool event(QEvent *event);
+    void updateCurrentTime(int);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+    virtual void updateCurrentValue(const QVariant &value) = 0;
+    virtual QVariant interpolated(const QVariant &from, const QVariant &to, qreal progress) const;
+private:
+    template <typename T> friend void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal));
+    static void registerInterpolator(Interpolator func, int interpolationType);
+    QVariantAnimation(const QVariantAnimation &); QVariantAnimation &operator=(const QVariantAnimation &);
+    inline QVariantAnimationPrivate* d_func() { return reinterpret_cast<QVariantAnimationPrivate *>(qGetPtrHelper(d_ptr)); } inline const QVariantAnimationPrivate* d_func() const { return reinterpret_cast<const QVariantAnimationPrivate *>(qGetPtrHelper(d_ptr)); } friend class QVariantAnimationPrivate;
+};
+template <typename T>
+void qRegisterAnimationInterpolator(QVariant (*func)(const T &from, const T &to, qreal progress)) {
+    QVariantAnimation::registerInterpolator(reinterpret_cast<QVariantAnimation::Interpolator>(func), qMetaTypeId<T>());
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QPropertyAnimationPrivate;
+class QPropertyAnimation : public QVariantAnimation
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QPropertyAnimation(QObject *parent = 0);
+    QPropertyAnimation(QObject *target, const QByteArray &propertyName, QObject *parent = 0);
+    ~QPropertyAnimation();
+    QObject *targetObject() const;
+    void setTargetObject(QObject *target);
+    QByteArray propertyName() const;
+    void setPropertyName(const QByteArray &propertyName);
+protected:
+    bool event(QEvent *event);
+    void updateCurrentValue(const QVariant &value);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+private:
+    QPropertyAnimation(const QPropertyAnimation &); QPropertyAnimation &operator=(const QPropertyAnimation &);
+    inline QPropertyAnimationPrivate* d_func() { return reinterpret_cast<QPropertyAnimationPrivate *>(qGetPtrHelper(d_ptr)); } inline const QPropertyAnimationPrivate* d_func() const { return reinterpret_cast<const QPropertyAnimationPrivate *>(qGetPtrHelper(d_ptr)); } friend class QPropertyAnimationPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QPauseAnimation;
+class QSequentialAnimationGroupPrivate;
+class QSequentialAnimationGroup : public QAnimationGroup
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QSequentialAnimationGroup(QObject *parent = 0);
+    ~QSequentialAnimationGroup();
+    QPauseAnimation *addPause(int msecs);
+    QPauseAnimation *insertPause(int index, int msecs);
+    QAbstractAnimation *currentAnimation() const;
+    int duration() const;
+protected:
+    void currentAnimationChanged(QAbstractAnimation *current);
+protected:
+    QSequentialAnimationGroup(QSequentialAnimationGroupPrivate &dd, QObject *parent);
+    bool event(QEvent *event);
+    void updateCurrentTime(int);
+    void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
+    void updateDirection(QAbstractAnimation::Direction direction);
+private:
+    QSequentialAnimationGroup(const QSequentialAnimationGroup &); QSequentialAnimationGroup &operator=(const QSequentialAnimationGroup &);
+    inline QSequentialAnimationGroupPrivate* d_func() { return reinterpret_cast<QSequentialAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } inline const QSequentialAnimationGroupPrivate* d_func() const { return reinterpret_cast<const QSequentialAnimationGroupPrivate *>(qGetPtrHelper(d_ptr)); } friend class QSequentialAnimationGroupPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+inline void qbswap_helper(const uchar *src, uchar *dest, int size)
+{
+    for (int i = 0; i < size ; ++i) dest[i] = src[size - 1 - i];
+}
+template <typename T> inline void qbswap(const T src, uchar *dest)
+{
+    qbswap_helper(reinterpret_cast<const uchar *>(&src), dest, sizeof(T));
+}
+template <typename T> inline void qToUnaligned(const T src, uchar *dest)
+{
+    qMemCopy(dest, &src, sizeof(T));
+}
+template <typename T> inline T qFromLittleEndian(const uchar *src);
+template <> inline quint64 qFromLittleEndian<quint64>(const uchar *src)
+{
+    return 0
+        | src[0]
+        | src[1] * static_cast<unsigned long long>(0x0000000000000100ULL)
+        | src[2] * static_cast<unsigned long long>(0x0000000000010000ULL)
+        | src[3] * static_cast<unsigned long long>(0x0000000001000000ULL)
+        | src[4] * static_cast<unsigned long long>(0x0000000100000000ULL)
+        | src[5] * static_cast<unsigned long long>(0x0000010000000000ULL)
+        | src[6] * static_cast<unsigned long long>(0x0001000000000000ULL)
+        | src[7] * static_cast<unsigned long long>(0x0100000000000000ULL);
+}
+template <> inline quint32 qFromLittleEndian<quint32>(const uchar *src)
+{
+    return 0
+        | src[0]
+        | src[1] * quint32(0x00000100)
+        | src[2] * quint32(0x00010000)
+        | src[3] * quint32(0x01000000);
+}
+template <> inline quint16 qFromLittleEndian<quint16>(const uchar *src)
+{
+    return quint16(0
+                   | src[0]
+                   | src[1] * 0x0100);
+}
+template <> inline qint64 qFromLittleEndian<qint64>(const uchar *src)
+{ return static_cast<qint64>(qFromLittleEndian<quint64>(src)); }
+template <> inline qint32 qFromLittleEndian<qint32>(const uchar *src)
+{ return static_cast<qint32>(qFromLittleEndian<quint32>(src)); }
+template <> inline qint16 qFromLittleEndian<qint16>(const uchar *src)
+{ return static_cast<qint16>(qFromLittleEndian<quint16>(src)); }
+template <class T> inline T qFromBigEndian(const uchar *src);
+template<>
+inline quint64 qFromBigEndian<quint64>(const uchar *src)
+{
+    return 0
+        | src[7]
+        | src[6] * static_cast<unsigned long long>(0x0000000000000100ULL)
+        | src[5] * static_cast<unsigned long long>(0x0000000000010000ULL)
+        | src[4] * static_cast<unsigned long long>(0x0000000001000000ULL)
+        | src[3] * static_cast<unsigned long long>(0x0000000100000000ULL)
+        | src[2] * static_cast<unsigned long long>(0x0000010000000000ULL)
+        | src[1] * static_cast<unsigned long long>(0x0001000000000000ULL)
+        | src[0] * static_cast<unsigned long long>(0x0100000000000000ULL);
+}
+template<>
+inline quint32 qFromBigEndian<quint32>(const uchar *src)
+{
+    return 0
+        | src[3]
+        | src[2] * quint32(0x00000100)
+        | src[1] * quint32(0x00010000)
+        | src[0] * quint32(0x01000000);
+}
+template<>
+inline quint16 qFromBigEndian<quint16>(const uchar *src)
+{
+    return quint16( 0
+                    | src[1]
+                    | src[0] * quint16(0x0100));
+}
+template <> inline qint64 qFromBigEndian<qint64>(const uchar *src)
+{ return static_cast<qint64>(qFromBigEndian<quint64>(src)); }
+template <> inline qint32 qFromBigEndian<qint32>(const uchar *src)
+{ return static_cast<qint32>(qFromBigEndian<quint32>(src)); }
+template <> inline qint16 qFromBigEndian<qint16>(const uchar *src)
+{ return static_cast<qint16>(qFromBigEndian<quint16>(src)); }
+template <typename T> T qbswap(T source);
+template <> inline quint64 qbswap<quint64>(quint64 source)
+{
+    return (__extension__ ({ union { __extension__ unsigned long long int __ll; unsigned int __l[2]; } __w, __r; if (__builtin_constant_p (source)) __r.__ll = (__extension__ ((((source) & 0xff00000000000000ull) >> 56) | (((source) & 0x00ff000000000000ull) >> 40) | (((source) & 0x0000ff0000000000ull) >> 24) | (((source) & 0x000000ff00000000ull) >> 8) | (((source) & 0x00000000ff000000ull) << 8) | (((source) & 0x0000000000ff0000ull) << 24) | (((source) & 0x000000000000ff00ull) << 40) | (((source) & 0x00000000000000ffull) << 56))); else { __w.__ll = (source); __r.__l[0] = (__extension__ ({ register unsigned int __bsx = (__w.__l[1]); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); })); __r.__l[1] = (__extension__ ({ register unsigned int __bsx = (__w.__l[0]); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); })); } __r.__ll; }));
+}
+template <> inline quint32 qbswap<quint32>(quint32 source)
+{
+    return (__extension__ ({ register unsigned int __bsx = (source); ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); }));
+}
+template <> inline quint16 qbswap<quint16>(quint16 source)
+{
+    return (__extension__ ({ unsigned short int __bsx = (source); ((((__bsx) >> 8) & 0xffu) | (((__bsx) & 0xffu) << 8)); }));
+}
+template <> inline qint64 qbswap<qint64>(qint64 source)
+{
+    return qbswap<quint64>(quint64(source));
+}
+template <> inline qint32 qbswap<qint32>(qint32 source)
+{
+    return qbswap<quint32>(quint32(source));
+}
+template <> inline qint16 qbswap<qint16>(qint16 source)
+{
+    return qbswap<quint16>(quint16(source));
+}
+template <typename T> inline T qToBigEndian(T source)
+{ return source; }
+template <typename T> inline T qFromBigEndian(T source)
+{ return source; }
+template <typename T> inline T qToLittleEndian(T source)
+{ return qbswap<T>(source); }
+template <typename T> inline T qFromLittleEndian(T source)
+{ return qbswap<T>(source); }
+template <typename T> inline void qToBigEndian(T src, uchar *dest)
+{ qToUnaligned<T>(src, dest); }
+template <typename T> inline void qToLittleEndian(T src, uchar *dest)
+{ qbswap<T>(src, dest); }
+template <> inline quint8 qbswap<quint8>(quint8 source)
+{
+    return source;
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLibraryInfo
+{
+public:
+    static QString licensee();
+    static QString licensedProducts();
+    static QString buildKey();
+    static QDate buildDate();
+    enum LibraryLocation
+    {
+        PrefixPath,
+        DocumentationPath,
+        HeadersPath,
+        LibrariesPath,
+        BinariesPath,
+        PluginsPath,
+        DataPath,
+        TranslationsPath,
+        SettingsPath,
+        DemosPath,
+        ExamplesPath,
+        ImportsPath
+    };
+    static QString location(LibraryLocation);
+private:
+    QLibraryInfo();
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+ bool qIsInf(double d);
+ bool qIsNaN(double d);
+ bool qIsFinite(double d);
+ bool qIsInf(float f);
+ bool qIsNaN(float f);
+ bool qIsFinite(float f);
+ double qSNaN();
+ double qQNaN();
+ double qInf();
+typedef QtValidLicenseForCoreModule QtCoreModule;
+struct QReadWriteLockPrivate;
+class QReadWriteLock
+{
+public:
+    enum RecursionMode { NonRecursive, Recursive };
+    QReadWriteLock();
+    QReadWriteLock(RecursionMode recursionMode);
+    ~QReadWriteLock();
+    void lockForRead();
+    bool tryLockForRead();
+    bool tryLockForRead(int timeout);
+    void lockForWrite();
+    bool tryLockForWrite();
+    bool tryLockForWrite(int timeout);
+    void unlock();
+private:
+    QReadWriteLock(const QReadWriteLock &); QReadWriteLock &operator=(const QReadWriteLock &);
+    QReadWriteLockPrivate *d;
+    friend class QWaitCondition;
+};
+class QReadLocker
+{
+public:
+    inline QReadLocker(QReadWriteLock *readWriteLock);
+    inline ~QReadLocker()
+    { unlock(); }
+    inline void unlock()
+    {
+        if (q_val) {
+            if ((q_val & quintptr(1u)) == quintptr(1u)) {
+                q_val &= ~quintptr(1u);
+                readWriteLock()->unlock();
+            }
+        }
+    }
+    inline void relock()
+    {
+        if (q_val) {
+            if ((q_val & quintptr(1u)) == quintptr(0u)) {
+                readWriteLock()->lockForRead();
+                q_val |= quintptr(1u);
+            }
+        }
+    }
+    inline QReadWriteLock *readWriteLock() const
+    { return reinterpret_cast<QReadWriteLock *>(q_val & ~quintptr(1u)); }
+private:
+    QReadLocker(const QReadLocker &); QReadLocker &operator=(const QReadLocker &);
+    quintptr q_val;
+};
+inline QReadLocker::QReadLocker(QReadWriteLock *areadWriteLock)
+    : q_val(reinterpret_cast<quintptr>(areadWriteLock))
+{
+    qt_noop()
+                                                                     ;
+    relock();
+}
+class QWriteLocker
+{
+public:
+    inline QWriteLocker(QReadWriteLock *readWriteLock);
+    inline ~QWriteLocker()
+    { unlock(); }
+    inline void unlock()
+    {
+        if (q_val) {
+            if ((q_val & quintptr(1u)) == quintptr(1u)) {
+                q_val &= ~quintptr(1u);
+                readWriteLock()->unlock();
+            }
+        }
+    }
+    inline void relock()
+    {
+        if (q_val) {
+            if ((q_val & quintptr(1u)) == quintptr(0u)) {
+                readWriteLock()->lockForWrite();
+                q_val |= quintptr(1u);
+            }
+        }
+    }
+    inline QReadWriteLock *readWriteLock() const
+    { return reinterpret_cast<QReadWriteLock *>(q_val & ~quintptr(1u)); }
+private:
+    QWriteLocker(const QWriteLocker &); QWriteLocker &operator=(const QWriteLocker &);
+    quintptr q_val;
+};
+inline QWriteLocker::QWriteLocker(QReadWriteLock *areadWriteLock)
+    : q_val(reinterpret_cast<quintptr>(areadWriteLock))
+{
+    qt_noop()
+                                                                      ;
+    relock();
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QThreadStorageData
+{
+public:
+    explicit QThreadStorageData(void (*func)(void *));
+    ~QThreadStorageData();
+    void** get() const;
+    void** set(void* p);
+    static void finish(void**);
+    int id;
+};
+template <typename T>
+inline
+T *&qThreadStorage_localData(QThreadStorageData &d, T **)
+{
+    void **v = d.get();
+    if (!v) v = d.set(0);
+    return *(reinterpret_cast<T**>(v));
+}
+template <typename T>
+inline
+T *qThreadStorage_localData_const(const QThreadStorageData &d, T **)
+{
+    void **v = d.get();
+    return v ? *(reinterpret_cast<T**>(v)) : 0;
+}
+template <typename T>
+inline
+void qThreadStorage_setLocalData(QThreadStorageData &d, T **t)
+{ (void) d.set(*t); }
+template <typename T>
+inline
+void qThreadStorage_deleteData(void *d, T **)
+{ delete static_cast<T *>(d); }
+template <typename T>
+inline
+T &qThreadStorage_localData(QThreadStorageData &d, T *)
+{
+    void **v = d.get();
+    if (!v) v = d.set(new T());
+    return *(reinterpret_cast<T*>(*v));
+}
+template <typename T>
+inline
+T qThreadStorage_localData_const(const QThreadStorageData &d, T *)
+{
+    void **v = d.get();
+    return v ? *(reinterpret_cast<T*>(*v)) : T();
+}
+template <typename T>
+inline
+void qThreadStorage_setLocalData(QThreadStorageData &d, T *t)
+{ (void) d.set(new T(*t)); }
+template <typename T>
+inline
+void qThreadStorage_deleteData(void *d, T *)
+{ delete static_cast<T *>(d); }
+template <class T>
+class QThreadStorage
+{
+private:
+    QThreadStorageData d;
+    QThreadStorage(const QThreadStorage &); QThreadStorage &operator=(const QThreadStorage &);
+    static inline void deleteData(void *x)
+    { qThreadStorage_deleteData(x, reinterpret_cast<T*>(0)); }
+public:
+    inline QThreadStorage() : d(deleteData) { }
+    inline ~QThreadStorage() { }
+    inline bool hasLocalData() const
+    { return d.get() != 0; }
+    inline T& localData()
+    { return qThreadStorage_localData(d, reinterpret_cast<T*>(0)); }
+    inline T localData() const
+    { return qThreadStorage_localData_const(d, reinterpret_cast<T*>(0)); }
+    inline void setLocalData(T t)
+    { qThreadStorage_setLocalData(d, &t); }
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QState;
+class QStateMachine;
+class QAbstractStatePrivate;
+class QAbstractState : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    ~QAbstractState();
+    QState *parentState() const;
+    QStateMachine *machine() const;
+protected:
+private:
+    void entered();
+    void exited();
+protected:
+    QAbstractState(QState *parent = 0);
+    virtual void onEntry(QEvent *event) = 0;
+    virtual void onExit(QEvent *event) = 0;
+    bool event(QEvent *e);
+protected:
+    QAbstractState(QAbstractStatePrivate &dd, QState *parent);
+private:
+    QAbstractState(const QAbstractState &); QAbstractState &operator=(const QAbstractState &);
+    inline QAbstractStatePrivate* d_func() { return reinterpret_cast<QAbstractStatePrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractStatePrivate* d_func() const { return reinterpret_cast<const QAbstractStatePrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractStatePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEvent;
+class QAbstractState;
+class QState;
+class QStateMachine;
+class QAbstractAnimation;
+class QAbstractTransitionPrivate;
+class QAbstractTransition : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QAbstractTransition(QState *sourceState = 0);
+    virtual ~QAbstractTransition();
+    QState *sourceState() const;
+    QAbstractState *targetState() const;
+    void setTargetState(QAbstractState* target);
+    QList<QAbstractState*> targetStates() const;
+    void setTargetStates(const QList<QAbstractState*> &targets);
+    QStateMachine *machine() const;
+    void addAnimation(QAbstractAnimation *animation);
+    void removeAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation*> animations() const;
+protected:
+private:
+    void triggered();
+protected:
+    virtual bool eventTest(QEvent *event) = 0;
+    virtual void onTransition(QEvent *event) = 0;
+    bool event(QEvent *e);
+protected:
+    QAbstractTransition(QAbstractTransitionPrivate &dd, QState *parent);
+private:
+    QAbstractTransition(const QAbstractTransition &); QAbstractTransition &operator=(const QAbstractTransition &);
+    inline QAbstractTransitionPrivate* d_func() { return reinterpret_cast<QAbstractTransitionPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractTransitionPrivate* d_func() const { return reinterpret_cast<const QAbstractTransitionPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractTransitionPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEventPrivate;
+class QEvent
+{
+    public: static const QMetaObject staticMetaObject; private:
+public:
+    enum Type {
+        None = 0,
+        Timer = 1,
+        MouseButtonPress = 2,
+        MouseButtonRelease = 3,
+        MouseButtonDblClick = 4,
+        MouseMove = 5,
+        KeyPress = 6,
+        KeyRelease = 7,
+        FocusIn = 8,
+        FocusOut = 9,
+        Enter = 10,
+        Leave = 11,
+        Paint = 12,
+        Move = 13,
+        Resize = 14,
+        Create = 15,
+        Destroy = 16,
+        Show = 17,
+        Hide = 18,
+        Close = 19,
+        Quit = 20,
+        ParentChange = 21,
+        ParentAboutToChange = 131,
+        ThreadChange = 22,
+        WindowActivate = 24,
+        WindowDeactivate = 25,
+        ShowToParent = 26,
+        HideToParent = 27,
+        Wheel = 31,
+        WindowTitleChange = 33,
+        WindowIconChange = 34,
+        ApplicationWindowIconChange = 35,
+        ApplicationFontChange = 36,
+        ApplicationLayoutDirectionChange = 37,
+        ApplicationPaletteChange = 38,
+        PaletteChange = 39,
+        Clipboard = 40,
+        Speech = 42,
+        MetaCall = 43,
+        SockAct = 50,
+        WinEventAct = 132,
+        DeferredDelete = 52,
+        DragEnter = 60,
+        DragMove = 61,
+        DragLeave = 62,
+        Drop = 63,
+        DragResponse = 64,
+        ChildAdded = 68,
+        ChildPolished = 69,
+        ChildRemoved = 71,
+        ShowWindowRequest = 73,
+        PolishRequest = 74,
+        Polish = 75,
+        LayoutRequest = 76,
+        UpdateRequest = 77,
+        UpdateLater = 78,
+        EmbeddingControl = 79,
+        ActivateControl = 80,
+        DeactivateControl = 81,
+        ContextMenu = 82,
+        InputMethod = 83,
+        AccessibilityPrepare = 86,
+        TabletMove = 87,
+        LocaleChange = 88,
+        LanguageChange = 89,
+        LayoutDirectionChange = 90,
+        Style = 91,
+        TabletPress = 92,
+        TabletRelease = 93,
+        OkRequest = 94,
+        HelpRequest = 95,
+        IconDrag = 96,
+        FontChange = 97,
+        EnabledChange = 98,
+        ActivationChange = 99,
+        StyleChange = 100,
+        IconTextChange = 101,
+        ModifiedChange = 102,
+        MouseTrackingChange = 109,
+        WindowBlocked = 103,
+        WindowUnblocked = 104,
+        WindowStateChange = 105,
+        ToolTip = 110,
+        WhatsThis = 111,
+        StatusTip = 112,
+        ActionChanged = 113,
+        ActionAdded = 114,
+        ActionRemoved = 115,
+        FileOpen = 116,
+        Shortcut = 117,
+        ShortcutOverride = 51,
+        WhatsThisClicked = 118,
+        ToolBarChange = 120,
+        ApplicationActivate = 121,
+        ApplicationActivated = ApplicationActivate,
+        ApplicationDeactivate = 122,
+        ApplicationDeactivated = ApplicationDeactivate,
+        QueryWhatsThis = 123,
+        EnterWhatsThisMode = 124,
+        LeaveWhatsThisMode = 125,
+        ZOrderChange = 126,
+        HoverEnter = 127,
+        HoverLeave = 128,
+        HoverMove = 129,
+        AccessibilityHelp = 119,
+        AccessibilityDescription = 130,
+        AcceptDropsChange = 152,
+        MenubarUpdated = 153,
+        ZeroTimerEvent = 154,
+        GraphicsSceneMouseMove = 155,
+        GraphicsSceneMousePress = 156,
+        GraphicsSceneMouseRelease = 157,
+        GraphicsSceneMouseDoubleClick = 158,
+        GraphicsSceneContextMenu = 159,
+        GraphicsSceneHoverEnter = 160,
+        GraphicsSceneHoverMove = 161,
+        GraphicsSceneHoverLeave = 162,
+        GraphicsSceneHelp = 163,
+        GraphicsSceneDragEnter = 164,
+        GraphicsSceneDragMove = 165,
+        GraphicsSceneDragLeave = 166,
+        GraphicsSceneDrop = 167,
+        GraphicsSceneWheel = 168,
+        KeyboardLayoutChange = 169,
+        DynamicPropertyChange = 170,
+        TabletEnterProximity = 171,
+        TabletLeaveProximity = 172,
+        NonClientAreaMouseMove = 173,
+        NonClientAreaMouseButtonPress = 174,
+        NonClientAreaMouseButtonRelease = 175,
+        NonClientAreaMouseButtonDblClick = 176,
+        MacSizeChange = 177,
+        ContentsRectChange = 178,
+        MacGLWindowChange = 179,
+        FutureCallOut = 180,
+        GraphicsSceneResize = 181,
+        GraphicsSceneMove = 182,
+        CursorChange = 183,
+        ToolTipChange = 184,
+        NetworkReplyUpdated = 185,
+        GrabMouse = 186,
+        UngrabMouse = 187,
+        GrabKeyboard = 188,
+        UngrabKeyboard = 189,
+        MacGLClearDrawable = 191,
+        StateMachineSignal = 192,
+        StateMachineWrapped = 193,
+        TouchBegin = 194,
+        TouchUpdate = 195,
+        TouchEnd = 196,
+        NativeGesture = 197,
+        RequestSoftwareInputPanel = 199,
+        CloseSoftwareInputPanel = 200,
+        UpdateSoftKeys = 201,
+        WinIdChange = 203,
+        Gesture = 198,
+        GestureOverride = 202,
+        PlatformPanel = 212,
+        User = 1000,
+        MaxUser = 65535
+    };
+    QEvent(Type type);
+    virtual ~QEvent();
+    inline Type type() const { return static_cast<Type>(t); }
+    inline bool spontaneous() const { return spont; }
+    inline void setAccepted(bool accepted) { m_accept = accepted; }
+    inline bool isAccepted() const { return m_accept; }
+    inline void accept() { m_accept = true; }
+    inline void ignore() { m_accept = false; }
+    static int registerEventType(int hint = -1);
+protected:
+    QEventPrivate *d;
+    ushort t;
+private:
+    ushort posted : 1;
+    ushort spont : 1;
+    ushort m_accept : 1;
+    ushort reserved : 13;
+    friend class QCoreApplication;
+    friend class QCoreApplicationPrivate;
+    friend class QThreadData;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class Q3AccelManager;
+    friend class QShortcutMap;
+    friend class QETWidget;
+    friend class QGraphicsView;
+    friend class QGraphicsViewPrivate;
+    friend class QGraphicsScene;
+    friend class QGraphicsScenePrivate;
+    friend class QGestureManager;
+};
+class QTimerEvent : public QEvent
+{
+public:
+    QTimerEvent( int timerId );
+    ~QTimerEvent();
+    int timerId() const { return id; }
+protected:
+    int id;
+};
+class QObject;
+class QChildEvent : public QEvent
+{
+public:
+    QChildEvent( Type type, QObject *child );
+    ~QChildEvent();
+    QObject *child() const { return c; }
+    bool added() const { return type() == ChildAdded; }
+    bool polished() const { return type() == ChildPolished; }
+    bool removed() const { return type() == ChildRemoved; }
+protected:
+    QObject *c;
+};
+class QDynamicPropertyChangeEvent : public QEvent
+{
+public:
+    QDynamicPropertyChangeEvent(const QByteArray &name);
+    ~QDynamicPropertyChangeEvent();
+    inline QByteArray propertyName() const { return n; }
+private:
+    QByteArray n;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEventTransitionPrivate;
+class QEventTransition : public QAbstractTransition
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QEventTransition(QState *sourceState = 0);
+    QEventTransition(QObject *object, QEvent::Type type, QState *sourceState = 0);
+    ~QEventTransition();
+    QObject *eventSource() const;
+    void setEventSource(QObject *object);
+    QEvent::Type eventType() const;
+    void setEventType(QEvent::Type type);
+protected:
+    bool eventTest(QEvent *event);
+    void onTransition(QEvent *event);
+    bool event(QEvent *e);
+protected:
+    QEventTransition(QEventTransitionPrivate &dd, QState *parent);
+    QEventTransition(QEventTransitionPrivate &dd, QObject *object,
+                     QEvent::Type type, QState *parent);
+private:
+    QEventTransition(const QEventTransition &); QEventTransition &operator=(const QEventTransition &);
+    inline QEventTransitionPrivate* d_func() { return reinterpret_cast<QEventTransitionPrivate *>(qGetPtrHelper(d_ptr)); } inline const QEventTransitionPrivate* d_func() const { return reinterpret_cast<const QEventTransitionPrivate *>(qGetPtrHelper(d_ptr)); } friend class QEventTransitionPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QFinalStatePrivate;
+class QFinalState : public QAbstractState
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QFinalState(QState *parent = 0);
+    ~QFinalState();
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    bool event(QEvent *e);
+private:
+    QFinalState(const QFinalState &); QFinalState &operator=(const QFinalState &);
+    inline QFinalStatePrivate* d_func() { return reinterpret_cast<QFinalStatePrivate *>(qGetPtrHelper(d_ptr)); } inline const QFinalStatePrivate* d_func() const { return reinterpret_cast<const QFinalStatePrivate *>(qGetPtrHelper(d_ptr)); } friend class QFinalStatePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QHistoryStatePrivate;
+class QHistoryState : public QAbstractState
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum HistoryType {
+        ShallowHistory,
+        DeepHistory
+    };
+    QHistoryState(QState *parent = 0);
+    QHistoryState(HistoryType type, QState *parent = 0);
+    ~QHistoryState();
+    QAbstractState *defaultState() const;
+    void setDefaultState(QAbstractState *state);
+    HistoryType historyType() const;
+    void setHistoryType(HistoryType type);
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    bool event(QEvent *e);
+private:
+    QHistoryState(const QHistoryState &); QHistoryState &operator=(const QHistoryState &);
+    inline QHistoryStatePrivate* d_func() { return reinterpret_cast<QHistoryStatePrivate *>(qGetPtrHelper(d_ptr)); } inline const QHistoryStatePrivate* d_func() const { return reinterpret_cast<const QHistoryStatePrivate *>(qGetPtrHelper(d_ptr)); } friend class QHistoryStatePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSignalTransitionPrivate;
+class QSignalTransition : public QAbstractTransition
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QSignalTransition(QState *sourceState = 0);
+    QSignalTransition(QObject *sender, const char *signal,
+                      QState *sourceState = 0);
+    ~QSignalTransition();
+    QObject *senderObject() const;
+    void setSenderObject(QObject *sender);
+    QByteArray signal() const;
+    void setSignal(const QByteArray &signal);
+protected:
+    bool eventTest(QEvent *event);
+    void onTransition(QEvent *event);
+    bool event(QEvent *e);
+private:
+    QSignalTransition(const QSignalTransition &); QSignalTransition &operator=(const QSignalTransition &);
+    inline QSignalTransitionPrivate* d_func() { return reinterpret_cast<QSignalTransitionPrivate *>(qGetPtrHelper(d_ptr)); } inline const QSignalTransitionPrivate* d_func() const { return reinterpret_cast<const QSignalTransitionPrivate *>(qGetPtrHelper(d_ptr)); } friend class QSignalTransitionPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAbstractTransition;
+class QSignalTransition;
+class QStatePrivate;
+class QState : public QAbstractState
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum ChildMode {
+        ExclusiveStates,
+        ParallelStates
+    };
+    QState(QState *parent = 0);
+    QState(ChildMode childMode, QState *parent = 0);
+    ~QState();
+    QAbstractState *errorState() const;
+    void setErrorState(QAbstractState *state);
+    void addTransition(QAbstractTransition *transition);
+    QSignalTransition *addTransition(QObject *sender, const char *signal, QAbstractState *target);
+    QAbstractTransition *addTransition(QAbstractState *target);
+    void removeTransition(QAbstractTransition *transition);
+    QList<QAbstractTransition*> transitions() const;
+    QAbstractState *initialState() const;
+    void setInitialState(QAbstractState *state);
+    ChildMode childMode() const;
+    void setChildMode(ChildMode mode);
+    void assignProperty(QObject *object, const char *name,
+                        const QVariant &value);
+protected:
+    void finished();
+    void propertiesAssigned();
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    bool event(QEvent *e);
+protected:
+    QState(QStatePrivate &dd, QState *parent);
+private:
+    QState(const QState &); QState &operator=(const QState &);
+    inline QStatePrivate* d_func() { return reinterpret_cast<QStatePrivate *>(qGetPtrHelper(d_ptr)); } inline const QStatePrivate* d_func() const { return reinterpret_cast<const QStatePrivate *>(qGetPtrHelper(d_ptr)); } friend class QStatePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QStateMachinePrivate;
+class QAbstractAnimation;
+class QStateMachine : public QState
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    class SignalEvent : public QEvent
+    {
+    public:
+        SignalEvent(QObject *sender, int signalIndex,
+                     const QList<QVariant> &arguments);
+        ~SignalEvent();
+        inline QObject *sender() const { return m_sender; }
+        inline int signalIndex() const { return m_signalIndex; }
+        inline QList<QVariant> arguments() const { return m_arguments; }
+    private:
+        QObject *m_sender;
+        int m_signalIndex;
+        QList<QVariant> m_arguments;
+        friend class QSignalTransitionPrivate;
+    };
+    class WrappedEvent : public QEvent
+    {
+    public:
+        WrappedEvent(QObject *object, QEvent *event);
+        ~WrappedEvent();
+        inline QObject *object() const { return m_object; }
+        inline QEvent *event() const { return m_event; }
+    private:
+        QObject *m_object;
+        QEvent *m_event;
+    };
+    enum EventPriority {
+        NormalPriority,
+        HighPriority
+    };
+    enum RestorePolicy {
+        DontRestoreProperties,
+        RestoreProperties
+    };
+    enum Error {
+        NoError,
+        NoInitialStateError,
+        NoDefaultStateInHistoryStateError,
+        NoCommonAncestorForTransitionError
+    };
+    QStateMachine(QObject *parent = 0);
+    ~QStateMachine();
+    void addState(QAbstractState *state);
+    void removeState(QAbstractState *state);
+    Error error() const;
+    QString errorString() const;
+    void clearError();
+    bool isRunning() const;
+    bool isAnimated() const;
+    void setAnimated(bool enabled);
+    void addDefaultAnimation(QAbstractAnimation *animation);
+    QList<QAbstractAnimation *> defaultAnimations() const;
+    void removeDefaultAnimation(QAbstractAnimation *animation);
+    QStateMachine::RestorePolicy globalRestorePolicy() const;
+    void setGlobalRestorePolicy(QStateMachine::RestorePolicy restorePolicy);
+    void postEvent(QEvent *event, EventPriority priority = NormalPriority);
+    int postDelayedEvent(QEvent *event, int delay);
+    bool cancelDelayedEvent(int id);
+    QSet<QAbstractState*> configuration() const;
+    bool eventFilter(QObject *watched, QEvent *event);
+public :
+    void start();
+    void stop();
+protected:
+    void started();
+    void stopped();
+protected:
+    void onEntry(QEvent *event);
+    void onExit(QEvent *event);
+    virtual void beginSelectTransitions(QEvent *event);
+    virtual void endSelectTransitions(QEvent *event);
+    virtual void beginMicrostep(QEvent *event);
+    virtual void endMicrostep(QEvent *event);
+    bool event(QEvent *e);
+protected:
+    QStateMachine(QStateMachinePrivate &dd, QObject *parent);
+private:
+    QStateMachine(const QStateMachine &); QStateMachine &operator=(const QStateMachine &);
+    inline QStateMachinePrivate* d_func() { return reinterpret_cast<QStateMachinePrivate *>(qGetPtrHelper(d_ptr)); } inline const QStateMachinePrivate* d_func() const { return reinterpret_cast<const QStateMachinePrivate *>(qGetPtrHelper(d_ptr)); } friend class QStateMachinePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAbstractFileEngine;
+class QFilePrivate;
+class QFile : public QIODevice
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QFilePrivate* d_func() { return reinterpret_cast<QFilePrivate *>(qGetPtrHelper(d_ptr)); } inline const QFilePrivate* d_func() const { return reinterpret_cast<const QFilePrivate *>(qGetPtrHelper(d_ptr)); } friend class QFilePrivate;
+public:
+    enum FileError {
+        NoError = 0,
+        ReadError = 1,
+        WriteError = 2,
+        FatalError = 3,
+        ResourceError = 4,
+        OpenError = 5,
+        AbortError = 6,
+        TimeOutError = 7,
+        UnspecifiedError = 8,
+        RemoveError = 9,
+        RenameError = 10,
+        PositionError = 11,
+        ResizeError = 12,
+        PermissionsError = 13,
+        CopyError = 14
+    };
+    enum Permission {
+        ReadOwner = 0x4000, WriteOwner = 0x2000, ExeOwner = 0x1000,
+        ReadUser = 0x0400, WriteUser = 0x0200, ExeUser = 0x0100,
+        ReadGroup = 0x0040, WriteGroup = 0x0020, ExeGroup = 0x0010,
+        ReadOther = 0x0004, WriteOther = 0x0002, ExeOther = 0x0001
+    };
+    typedef QFlags<Permission> Permissions;
+    enum FileHandleFlag {
+        AutoCloseHandle = 0x0001,
+        DontCloseHandle = 0
+    };
+    typedef QFlags<FileHandleFlag> FileHandleFlags;
+    QFile();
+    QFile(const QString &name);
+    explicit QFile(QObject *parent);
+    QFile(const QString &name, QObject *parent);
+    ~QFile();
+    FileError error() const;
+    void unsetError();
+    QString fileName() const;
+    void setFileName(const QString &name);
+    typedef QByteArray (*EncoderFn)(const QString &fileName);
+    typedef QString (*DecoderFn)(const QByteArray &localfileName);
+    static QByteArray encodeName(const QString &fileName);
+    static QString decodeName(const QByteArray &localFileName);
+    inline static QString decodeName(const char *localFileName)
+        { return decodeName(QByteArray(localFileName)); }
+    static void setEncodingFunction(EncoderFn);
+    static void setDecodingFunction(DecoderFn);
+    bool exists() const;
+    static bool exists(const QString &fileName);
+    QString readLink() const;
+    static QString readLink(const QString &fileName);
+    inline QString symLinkTarget() const { return readLink(); }
+    inline static QString symLinkTarget(const QString &fileName) { return readLink(fileName); }
+    bool remove();
+    static bool remove(const QString &fileName);
+    bool rename(const QString &newName);
+    static bool rename(const QString &oldName, const QString &newName);
+    bool link(const QString &newName);
+    static bool link(const QString &oldname, const QString &newName);
+    bool copy(const QString &newName);
+    static bool copy(const QString &fileName, const QString &newName);
+    bool isSequential() const;
+    bool open(OpenMode flags);
+    bool open(FILE *f, OpenMode flags);
+    bool open(int fd, OpenMode flags);
+    bool open(FILE *f, OpenMode ioFlags, FileHandleFlags handleFlags);
+    bool open(int fd, OpenMode ioFlags, FileHandleFlags handleFlags);
+    virtual void close();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64 offset);
+    bool atEnd() const;
+    bool flush();
+    bool resize(qint64 sz);
+    static bool resize(const QString &filename, qint64 sz);
+    Permissions permissions() const;
+    static Permissions permissions(const QString &filename);
+    bool setPermissions(Permissions permissionSpec);
+    static bool setPermissions(const QString &filename, Permissions permissionSpec);
+    int handle() const;
+    enum MemoryMapFlags {
+        NoOptions = 0
+    };
+    uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions);
+    bool unmap(uchar *address);
+    virtual QAbstractFileEngine *fileEngine() const;
+protected:
+    QFile(QFilePrivate &dd, QObject *parent = 0);
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+    qint64 readLineData(char *data, qint64 maxlen);
+private:
+    QFile(const QFile &); QFile &operator=(const QFile &);
+};
+ inline QFlags<QFile::Permissions::enum_type> operator|(QFile::Permissions::enum_type f1, QFile::Permissions::enum_type f2) { return QFlags<QFile::Permissions::enum_type>(f1) | f2; } inline QFlags<QFile::Permissions::enum_type> operator|(QFile::Permissions::enum_type f1, QFlags<QFile::Permissions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QFile::Permissions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDir;
+class QDirIteratorPrivate;
+class QDateTime;
+class QFileInfoPrivate;
+class QFileInfo
+{
+    friend class QDirIteratorPrivate;
+public:
+    explicit QFileInfo(QFileInfoPrivate *d);
+    QFileInfo();
+    QFileInfo(const QString &file);
+    QFileInfo(const QFile &file);
+    QFileInfo(const QDir &dir, const QString &file);
+    QFileInfo(const QFileInfo &fileinfo);
+    ~QFileInfo();
+    QFileInfo &operator=(const QFileInfo &fileinfo);
+    bool operator==(const QFileInfo &fileinfo);
+    bool operator==(const QFileInfo &fileinfo) const;
+    inline bool operator!=(const QFileInfo &fileinfo) { return !(operator==(fileinfo)); }
+    inline bool operator!=(const QFileInfo &fileinfo) const { return !(operator==(fileinfo)); }
+    void setFile(const QString &file);
+    void setFile(const QFile &file);
+    void setFile(const QDir &dir, const QString &file);
+    bool exists() const;
+    void refresh();
+    QString filePath() const;
+    QString absoluteFilePath() const;
+    QString canonicalFilePath() const;
+    QString fileName() const;
+    QString baseName() const;
+    QString completeBaseName() const;
+    QString suffix() const;
+    QString bundleName() const;
+    QString completeSuffix() const;
+    QString path() const;
+    QString absolutePath() const;
+    QString canonicalPath() const;
+    QDir dir() const;
+    QDir absoluteDir() const;
+    bool isReadable() const;
+    bool isWritable() const;
+    bool isExecutable() const;
+    bool isHidden() const;
+    bool isRelative() const;
+    inline bool isAbsolute() const { return !isRelative(); }
+    bool makeAbsolute();
+    bool isFile() const;
+    bool isDir() const;
+    bool isSymLink() const;
+    bool isRoot() const;
+    bool isBundle() const;
+    QString readLink() const;
+    inline QString symLinkTarget() const { return readLink(); }
+    QString owner() const;
+    uint ownerId() const;
+    QString group() const;
+    uint groupId() const;
+    bool permission(QFile::Permissions permissions) const;
+    QFile::Permissions permissions() const;
+    qint64 size() const;
+    QDateTime created() const;
+    QDateTime lastModified() const;
+    QDateTime lastRead() const;
+    void detach();
+    bool caching() const;
+    void setCaching(bool on);
+protected:
+    QSharedDataPointer<QFileInfoPrivate> d_ptr;
+private:
+    inline QFileInfoPrivate* d_func()
+    {
+        detach();
+        return const_cast<QFileInfoPrivate *>(d_ptr.constData());
+    }
+    inline const QFileInfoPrivate* d_func() const
+    {
+        return d_ptr.constData();
+    }
+};
+template<> class QTypeInfo<QFileInfo > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFileInfo)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QFileInfo"; } };
+typedef QList<QFileInfo> QFileInfoList;
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDirPrivate;
+class QDir
+{
+protected:
+    QSharedDataPointer<QDirPrivate> d_ptr;
+public:
+    enum Filter { Dirs = 0x001,
+                  Files = 0x002,
+                  Drives = 0x004,
+                  NoSymLinks = 0x008,
+                  AllEntries = Dirs | Files | Drives,
+                  TypeMask = 0x00f,
+                  Readable = 0x010,
+                  Writable = 0x020,
+                  Executable = 0x040,
+                  PermissionMask = 0x070,
+                  Modified = 0x080,
+                  Hidden = 0x100,
+                  System = 0x200,
+                  AccessMask = 0x3F0,
+                  AllDirs = 0x400,
+                  CaseSensitive = 0x800,
+                  NoDotAndDotDot = 0x1000,
+                  NoDot = 0x2000,
+                  NoDotDot = 0x4000,
+                  NoFilter = -1
+    };
+    typedef QFlags<Filter> Filters;
+    enum SortFlag { Name = 0x00,
+                    Time = 0x01,
+                    Size = 0x02,
+                    Unsorted = 0x03,
+                    SortByMask = 0x03,
+                    DirsFirst = 0x04,
+                    Reversed = 0x08,
+                    IgnoreCase = 0x10,
+                    DirsLast = 0x20,
+                    LocaleAware = 0x40,
+                    Type = 0x80,
+                    NoSort = -1
+    };
+    typedef QFlags<SortFlag> SortFlags;
+    QDir(const QDir &);
+    QDir(const QString &path = QString());
+    QDir(const QString &path, const QString &nameFilter,
+         SortFlags sort = SortFlags(Name | IgnoreCase), Filters filter = AllEntries);
+    ~QDir();
+    QDir &operator=(const QDir &);
+    QDir &operator=(const QString &path);
+    void setPath(const QString &path);
+    QString path() const;
+    QString absolutePath() const;
+    QString canonicalPath() const;
+    static void addResourceSearchPath(const QString &path);
+    static void setSearchPaths(const QString &prefix, const QStringList &searchPaths);
+    static void addSearchPath(const QString &prefix, const QString &path);
+    static QStringList searchPaths(const QString &prefix);
+    QString dirName() const;
+    QString filePath(const QString &fileName) const;
+    QString absoluteFilePath(const QString &fileName) const;
+    QString relativeFilePath(const QString &fileName) const;
+    static QString convertSeparators(const QString &pathName);
+    static QString toNativeSeparators(const QString &pathName);
+    static QString fromNativeSeparators(const QString &pathName);
+    bool cd(const QString &dirName);
+    bool cdUp();
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &nameFilters);
+    Filters filter() const;
+    void setFilter(Filters filter);
+    SortFlags sorting() const;
+    void setSorting(SortFlags sort);
+    uint count() const;
+    QString operator[](int) const;
+    static QStringList nameFiltersFromString(const QString &nameFilter);
+    QStringList entryList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
+    QStringList entryList(const QStringList &nameFilters, Filters filters = NoFilter,
+                          SortFlags sort = NoSort) const;
+    QFileInfoList entryInfoList(Filters filters = NoFilter, SortFlags sort = NoSort) const;
+    QFileInfoList entryInfoList(const QStringList &nameFilters, Filters filters = NoFilter,
+                                SortFlags sort = NoSort) const;
+    bool mkdir(const QString &dirName) const;
+    bool rmdir(const QString &dirName) const;
+    bool mkpath(const QString &dirPath) const;
+    bool rmpath(const QString &dirPath) const;
+    bool isReadable() const;
+    bool exists() const;
+    bool isRoot() const;
+    static bool isRelativePath(const QString &path);
+    inline static bool isAbsolutePath(const QString &path) { return !isRelativePath(path); }
+    bool isRelative() const;
+    inline bool isAbsolute() const { return !isRelative(); }
+    bool makeAbsolute();
+    bool operator==(const QDir &dir) const;
+    inline bool operator!=(const QDir &dir) const { return !operator==(dir); }
+    bool remove(const QString &fileName);
+    bool rename(const QString &oldName, const QString &newName);
+    bool exists(const QString &name) const;
+    static QFileInfoList drives();
+    static QChar separator();
+    static bool setCurrent(const QString &path);
+    static inline QDir current() { return QDir(currentPath()); }
+    static QString currentPath();
+    static inline QDir home() { return QDir(homePath()); }
+    static QString homePath();
+    static inline QDir root() { return QDir(rootPath()); }
+    static QString rootPath();
+    static inline QDir temp() { return QDir(tempPath()); }
+    static QString tempPath();
+    static bool match(const QStringList &filters, const QString &fileName);
+    static bool match(const QString &filter, const QString &fileName);
+    static QString cleanPath(const QString &path);
+    void refresh() const;
+};
+ inline QFlags<QDir::Filters::enum_type> operator|(QDir::Filters::enum_type f1, QDir::Filters::enum_type f2) { return QFlags<QDir::Filters::enum_type>(f1) | f2; } inline QFlags<QDir::Filters::enum_type> operator|(QDir::Filters::enum_type f1, QFlags<QDir::Filters::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QDir::Filters::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<QDir::SortFlags::enum_type> operator|(QDir::SortFlags::enum_type f1, QDir::SortFlags::enum_type f2) { return QFlags<QDir::SortFlags::enum_type>(f1) | f2; } inline QFlags<QDir::SortFlags::enum_type> operator|(QDir::SortFlags::enum_type f1, QFlags<QDir::SortFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QDir::SortFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+class QDebug;
+ QDebug operator<<(QDebug debug, QDir::Filters filters);
+ QDebug operator<<(QDebug debug, const QDir &dir);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QFileExtension;
+class QFileExtensionResult;
+class QVariant;
+class QAbstractFileEngineIterator;
+class QAbstractFileEnginePrivate;
+class QAbstractFileEngine
+{
+public:
+    enum FileFlag {
+        ReadOwnerPerm = 0x4000, WriteOwnerPerm = 0x2000, ExeOwnerPerm = 0x1000,
+        ReadUserPerm = 0x0400, WriteUserPerm = 0x0200, ExeUserPerm = 0x0100,
+        ReadGroupPerm = 0x0040, WriteGroupPerm = 0x0020, ExeGroupPerm = 0x0010,
+        ReadOtherPerm = 0x0004, WriteOtherPerm = 0x0002, ExeOtherPerm = 0x0001,
+        LinkType = 0x10000,
+        FileType = 0x20000,
+        DirectoryType = 0x40000,
+        BundleType = 0x80000,
+        HiddenFlag = 0x0100000,
+        LocalDiskFlag = 0x0200000,
+        ExistsFlag = 0x0400000,
+        RootFlag = 0x0800000,
+        Refresh = 0x1000000,
+        PermsMask = 0x0000FFFF,
+        TypesMask = 0x000F0000,
+        FlagsMask = 0x0FF00000,
+        FileInfoAll = FlagsMask | PermsMask | TypesMask
+    };
+    typedef QFlags<FileFlag> FileFlags;
+    enum FileName {
+        DefaultName,
+        BaseName,
+        PathName,
+        AbsoluteName,
+        AbsolutePathName,
+        LinkName,
+        CanonicalName,
+        CanonicalPathName,
+        BundleName,
+        NFileNames = 9
+    };
+    enum FileOwner {
+        OwnerUser,
+        OwnerGroup
+    };
+    enum FileTime {
+        CreationTime,
+        ModificationTime,
+        AccessTime
+    };
+    virtual ~QAbstractFileEngine();
+    virtual bool open(QIODevice::OpenMode openMode);
+    virtual bool close();
+    virtual bool flush();
+    virtual qint64 size() const;
+    virtual qint64 pos() const;
+    virtual bool seek(qint64 pos);
+    virtual bool isSequential() const;
+    virtual bool remove();
+    virtual bool copy(const QString &newName);
+    virtual bool rename(const QString &newName);
+    virtual bool link(const QString &newName);
+    virtual bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    virtual bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+    virtual bool setSize(qint64 size);
+    virtual bool caseSensitive() const;
+    virtual bool isRelativePath() const;
+    virtual QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+    virtual FileFlags fileFlags(FileFlags type=FileInfoAll) const;
+    virtual bool setPermissions(uint perms);
+    virtual QString fileName(FileName file=DefaultName) const;
+    virtual uint ownerId(FileOwner) const;
+    virtual QString owner(FileOwner) const;
+    virtual QDateTime fileTime(FileTime time) const;
+    virtual void setFileName(const QString &file);
+    virtual int handle() const;
+    bool atEnd() const;
+    uchar *map(qint64 offset, qint64 size, QFile::MemoryMapFlags flags);
+    bool unmap(uchar *ptr);
+    typedef QAbstractFileEngineIterator Iterator;
+    virtual Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    virtual Iterator *endEntryList();
+    virtual qint64 read(char *data, qint64 maxlen);
+    virtual qint64 readLine(char *data, qint64 maxlen);
+    virtual qint64 write(const char *data, qint64 len);
+    QFile::FileError error() const;
+    QString errorString() const;
+    enum Extension {
+        AtEndExtension,
+        FastReadLineExtension,
+        MapExtension,
+        UnMapExtension
+    };
+    class ExtensionOption
+    {};
+    class ExtensionReturn
+    {};
+    class MapExtensionOption : public ExtensionOption {
+    public:
+        qint64 offset;
+        qint64 size;
+        QFile::MemoryMapFlags flags;
+    };
+    class MapExtensionReturn : public ExtensionReturn {
+    public:
+        uchar *address;
+    };
+    class UnMapExtensionOption : public ExtensionOption {
+    public:
+        uchar *address;
+    };
+    virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    virtual bool supportsExtension(Extension extension) const;
+    static QAbstractFileEngine *create(const QString &fileName);
+protected:
+    void setError(QFile::FileError error, const QString &str);
+    QAbstractFileEngine();
+    QAbstractFileEngine(QAbstractFileEnginePrivate &);
+    QScopedPointer<QAbstractFileEnginePrivate> d_ptr;
+private:
+    inline QAbstractFileEnginePrivate* d_func() { return reinterpret_cast<QAbstractFileEnginePrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractFileEnginePrivate* d_func() const { return reinterpret_cast<const QAbstractFileEnginePrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractFileEnginePrivate;
+    QAbstractFileEngine(const QAbstractFileEngine &); QAbstractFileEngine &operator=(const QAbstractFileEngine &);
+};
+ inline QFlags<QAbstractFileEngine::FileFlags::enum_type> operator|(QAbstractFileEngine::FileFlags::enum_type f1, QAbstractFileEngine::FileFlags::enum_type f2) { return QFlags<QAbstractFileEngine::FileFlags::enum_type>(f1) | f2; } inline QFlags<QAbstractFileEngine::FileFlags::enum_type> operator|(QAbstractFileEngine::FileFlags::enum_type f1, QFlags<QAbstractFileEngine::FileFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QAbstractFileEngine::FileFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+class QAbstractFileEngineHandler
+{
+public:
+    QAbstractFileEngineHandler();
+    virtual ~QAbstractFileEngineHandler();
+    virtual QAbstractFileEngine *create(const QString &fileName) const = 0;
+};
+class QAbstractFileEngineIteratorPrivate;
+class QAbstractFileEngineIterator
+{
+public:
+    QAbstractFileEngineIterator(QDir::Filters filters, const QStringList &nameFilters);
+    virtual ~QAbstractFileEngineIterator();
+    virtual QString next() = 0;
+    virtual bool hasNext() const = 0;
+    QString path() const;
+    QStringList nameFilters() const;
+    QDir::Filters filters() const;
+    virtual QString currentFileName() const = 0;
+    virtual QFileInfo currentFileInfo() const;
+    QString currentFilePath() const;
+protected:
+    enum EntryInfoType {
+    };
+    virtual QVariant entryInfo(EntryInfoType type) const;
+private:
+    QAbstractFileEngineIterator(const QAbstractFileEngineIterator &); QAbstractFileEngineIterator &operator=(const QAbstractFileEngineIterator &);
+    friend class QDirIterator;
+    friend class QDirIteratorPrivate;
+    void setPath(const QString &path);
+    QScopedPointer<QAbstractFileEngineIteratorPrivate> d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QObject;
+class QBufferPrivate;
+class QBuffer : public QIODevice
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+     explicit QBuffer(QObject *parent = 0);
+     QBuffer(QByteArray *buf, QObject *parent = 0);
+    ~QBuffer();
+    QByteArray &buffer();
+    const QByteArray &buffer() const;
+    void setBuffer(QByteArray *a);
+    void setData(const QByteArray &data);
+    inline void setData(const char *data, int len);
+    const QByteArray &data() const;
+    bool open(OpenMode openMode);
+    void close();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64 off);
+    bool atEnd() const;
+    bool canReadLine() const;
+protected:
+    void connectNotify(const char*);
+    void disconnectNotify(const char*);
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+private:
+    inline QBufferPrivate* d_func() { return reinterpret_cast<QBufferPrivate *>(qGetPtrHelper(d_ptr)); } inline const QBufferPrivate* d_func() const { return reinterpret_cast<const QBufferPrivate *>(qGetPtrHelper(d_ptr)); } friend class QBufferPrivate;
+    QBuffer(const QBuffer &); QBuffer &operator=(const QBuffer &);
+};
+inline void QBuffer::setData(const char *adata, int alen)
+{ setData(QByteArray(adata, alen)); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QDirIteratorPrivate;
+class QDirIterator {
+public:
+    enum IteratorFlag {
+        NoIteratorFlags = 0x0,
+        FollowSymlinks = 0x1,
+        Subdirectories = 0x2
+    };
+    typedef QFlags<IteratorFlag> IteratorFlags;
+    QDirIterator(const QDir &dir, IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 QDir::Filters filter,
+                 IteratorFlags flags = NoIteratorFlags);
+    QDirIterator(const QString &path,
+                 const QStringList &nameFilters,
+                 QDir::Filters filters = QDir::NoFilter,
+                 IteratorFlags flags = NoIteratorFlags);
+    virtual ~QDirIterator();
+    QString next();
+    bool hasNext() const;
+    QString fileName() const;
+    QString filePath() const;
+    QFileInfo fileInfo() const;
+    QString path() const;
+private:
+    QDirIterator(const QDirIterator &); QDirIterator &operator=(const QDirIterator &);
+    QScopedPointer<QDirIteratorPrivate> d;
+    friend class QDir;
+};
+ inline QFlags<QDirIterator::IteratorFlags::enum_type> operator|(QDirIterator::IteratorFlags::enum_type f1, QDirIterator::IteratorFlags::enum_type f2) { return QFlags<QDirIterator::IteratorFlags::enum_type>(f1) | f2; } inline QFlags<QDirIterator::IteratorFlags::enum_type> operator|(QDirIterator::IteratorFlags::enum_type f1, QFlags<QDirIterator::IteratorFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QDirIterator::IteratorFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QFileSystemWatcherPrivate;
+class QFileSystemWatcher : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QFileSystemWatcherPrivate* d_func() { return reinterpret_cast<QFileSystemWatcherPrivate *>(qGetPtrHelper(d_ptr)); } inline const QFileSystemWatcherPrivate* d_func() const { return reinterpret_cast<const QFileSystemWatcherPrivate *>(qGetPtrHelper(d_ptr)); } friend class QFileSystemWatcherPrivate;
+public:
+    QFileSystemWatcher(QObject *parent = 0);
+    QFileSystemWatcher(const QStringList &paths, QObject *parent = 0);
+    ~QFileSystemWatcher();
+    void addPath(const QString &file);
+    void addPaths(const QStringList &files);
+    void removePath(const QString &file);
+    void removePaths(const QStringList &files);
+    QStringList files() const;
+    QStringList directories() const;
+protected:
+    void fileChanged(const QString &path);
+    void directoryChanged(const QString &path);
+private:
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QFSFileEnginePrivate;
+class QFSFileEngine : public QAbstractFileEngine
+{
+    inline QFSFileEnginePrivate* d_func() { return reinterpret_cast<QFSFileEnginePrivate *>(qGetPtrHelper(d_ptr)); } inline const QFSFileEnginePrivate* d_func() const { return reinterpret_cast<const QFSFileEnginePrivate *>(qGetPtrHelper(d_ptr)); } friend class QFSFileEnginePrivate;
+public:
+    QFSFileEngine();
+    explicit QFSFileEngine(const QString &file);
+    ~QFSFileEngine();
+    bool open(QIODevice::OpenMode openMode);
+    bool open(QIODevice::OpenMode flags, FILE *fh);
+    bool close();
+    bool flush();
+    qint64 size() const;
+    qint64 pos() const;
+    bool seek(qint64);
+    bool isSequential() const;
+    bool remove();
+    bool copy(const QString &newName);
+    bool rename(const QString &newName);
+    bool link(const QString &newName);
+    bool mkdir(const QString &dirName, bool createParentDirectories) const;
+    bool rmdir(const QString &dirName, bool recurseParentDirectories) const;
+    bool setSize(qint64 size);
+    bool caseSensitive() const;
+    bool isRelativePath() const;
+    QStringList entryList(QDir::Filters filters, const QStringList &filterNames) const;
+    FileFlags fileFlags(FileFlags type) const;
+    bool setPermissions(uint perms);
+    QString fileName(FileName file) const;
+    uint ownerId(FileOwner) const;
+    QString owner(FileOwner) const;
+    QDateTime fileTime(FileTime time) const;
+    void setFileName(const QString &file);
+    int handle() const;
+    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames);
+    Iterator *endEntryList();
+    qint64 read(char *data, qint64 maxlen);
+    qint64 readLine(char *data, qint64 maxlen);
+    qint64 write(const char *data, qint64 len);
+    bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    bool supportsExtension(Extension extension) const;
+    bool open(QIODevice::OpenMode flags, int fd);
+    bool open(QIODevice::OpenMode flags, int fd, QFile::FileHandleFlags handleFlags);
+    bool open(QIODevice::OpenMode flags, FILE *fh, QFile::FileHandleFlags handleFlags);
+    static bool setCurrentPath(const QString &path);
+    static QString currentPath(const QString &path = QString());
+    static QString homePath();
+    static QString rootPath();
+    static QString tempPath();
+    static QFileInfoList drives();
+protected:
+    QFSFileEngine(QFSFileEnginePrivate &dd);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+typedef qint64 Q_PID;
+class QProcessPrivate;
+class QProcessEnvironmentPrivate;
+class QProcessEnvironment
+{
+public:
+    QProcessEnvironment();
+    QProcessEnvironment(const QProcessEnvironment &other);
+    ~QProcessEnvironment();
+    QProcessEnvironment &operator=(const QProcessEnvironment &other);
+    bool operator==(const QProcessEnvironment &other) const;
+    inline bool operator!=(const QProcessEnvironment &other) const
+    { return !(*this == other); }
+    bool isEmpty() const;
+    void clear();
+    bool contains(const QString &name) const;
+    void insert(const QString &name, const QString &value);
+    void remove(const QString &name);
+    QString value(const QString &name, const QString &defaultValue = QString()) const;
+    QStringList toStringList() const;
+    QStringList keys() const;
+    void insert(const QProcessEnvironment &e);
+    static QProcessEnvironment systemEnvironment();
+private:
+    friend class QProcessPrivate;
+    friend class QProcessEnvironmentPrivate;
+    QSharedDataPointer<QProcessEnvironmentPrivate> d;
+};
+class QProcess : public QIODevice
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum ProcessError {
+        FailedToStart,
+        Crashed,
+        Timedout,
+        ReadError,
+        WriteError,
+        UnknownError
+    };
+    enum ProcessState {
+        NotRunning,
+        Starting,
+        Running
+    };
+    enum ProcessChannel {
+        StandardOutput,
+        StandardError
+    };
+    enum ProcessChannelMode {
+        SeparateChannels,
+        MergedChannels,
+        ForwardedChannels
+    };
+    enum ExitStatus {
+        NormalExit,
+        CrashExit
+    };
+    explicit QProcess(QObject *parent = 0);
+    virtual ~QProcess();
+    void start(const QString &program, const QStringList &arguments, OpenMode mode = ReadWrite);
+    void start(const QString &program, OpenMode mode = ReadWrite);
+    ProcessChannelMode readChannelMode() const;
+    void setReadChannelMode(ProcessChannelMode mode);
+    ProcessChannelMode processChannelMode() const;
+    void setProcessChannelMode(ProcessChannelMode mode);
+    ProcessChannel readChannel() const;
+    void setReadChannel(ProcessChannel channel);
+    void closeReadChannel(ProcessChannel channel);
+    void closeWriteChannel();
+    void setStandardInputFile(const QString &fileName);
+    void setStandardOutputFile(const QString &fileName, OpenMode mode = Truncate);
+    void setStandardErrorFile(const QString &fileName, OpenMode mode = Truncate);
+    void setStandardOutputProcess(QProcess *destination);
+    QString workingDirectory() const;
+    void setWorkingDirectory(const QString &dir);
+    void setEnvironment(const QStringList &environment);
+    QStringList environment() const;
+    void setProcessEnvironment(const QProcessEnvironment &environment);
+    QProcessEnvironment processEnvironment() const;
+    QProcess::ProcessError error() const;
+    QProcess::ProcessState state() const;
+    Q_PID pid() const;
+    bool waitForStarted(int msecs = 30000);
+    bool waitForReadyRead(int msecs = 30000);
+    bool waitForBytesWritten(int msecs = 30000);
+    bool waitForFinished(int msecs = 30000);
+    QByteArray readAllStandardOutput();
+    QByteArray readAllStandardError();
+    int exitCode() const;
+    QProcess::ExitStatus exitStatus() const;
+    qint64 bytesAvailable() const;
+    qint64 bytesToWrite() const;
+    bool isSequential() const;
+    bool canReadLine() const;
+    void close();
+    bool atEnd() const;
+    static int execute(const QString &program, const QStringList &arguments);
+    static int execute(const QString &program);
+    static bool startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory,
+                              qint64 *pid = 0);
+    static bool startDetached(const QString &program, const QStringList &arguments);
+    static bool startDetached(const QString &program);
+    static QStringList systemEnvironment();
+public :
+    void terminate();
+    void kill();
+protected:
+    void started();
+    void finished(int exitCode);
+    void finished(int exitCode, QProcess::ExitStatus exitStatus);
+    void error(QProcess::ProcessError error);
+    void stateChanged(QProcess::ProcessState state);
+    void readyReadStandardOutput();
+    void readyReadStandardError();
+protected:
+    void setProcessState(ProcessState state);
+    virtual void setupChildProcess();
+    qint64 readData(char *data, qint64 maxlen);
+    qint64 writeData(const char *data, qint64 len);
+private:
+    inline QProcessPrivate* d_func() { return reinterpret_cast<QProcessPrivate *>(qGetPtrHelper(d_ptr)); } inline const QProcessPrivate* d_func() const { return reinterpret_cast<const QProcessPrivate *>(qGetPtrHelper(d_ptr)); } friend class QProcessPrivate;
+    QProcess(const QProcess &); QProcess &operator=(const QProcess &);
+    friend class QProcessManager;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QResourcePrivate;
+class QResource
+{
+public:
+    QResource(const QString &file=QString(), const QLocale &locale=QLocale());
+    ~QResource();
+    void setFileName(const QString &file);
+    QString fileName() const;
+    QString absoluteFilePath() const;
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+    bool isValid() const;
+    bool isCompressed() const;
+    qint64 size() const;
+    const uchar *data() const;
+    static void addSearchPath(const QString &path);
+    static QStringList searchPaths();
+    static bool registerResource(const QString &rccFilename, const QString &resourceRoot=QString());
+    static bool unregisterResource(const QString &rccFilename, const QString &resourceRoot=QString());
+    static bool registerResource(const uchar *rccData, const QString &resourceRoot=QString());
+    static bool unregisterResource(const uchar *rccData, const QString &resourceRoot=QString());
+protected:
+    friend class QResourceFileEngine;
+    friend class QResourceFileEngineIterator;
+    bool isDir() const;
+    inline bool isFile() const { return !isDir(); }
+    QStringList children() const;
+protected:
+    QScopedPointer<QResourcePrivate> d_ptr;
+private:
+    inline QResourcePrivate* d_func() { return reinterpret_cast<QResourcePrivate *>(qGetPtrHelper(d_ptr)); } inline const QResourcePrivate* d_func() const { return reinterpret_cast<const QResourcePrivate *>(qGetPtrHelper(d_ptr)); } friend class QResourcePrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QIODevice;
+class QSettingsPrivate;
+class QSettings : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QSettingsPrivate* d_func() { return reinterpret_cast<QSettingsPrivate *>(qGetPtrHelper(d_ptr)); } inline const QSettingsPrivate* d_func() const { return reinterpret_cast<const QSettingsPrivate *>(qGetPtrHelper(d_ptr)); } friend class QSettingsPrivate;
+public:
+    enum Status {
+        NoError = 0,
+        AccessError,
+        FormatError
+    };
+    enum Format {
+        NativeFormat,
+        IniFormat,
+        InvalidFormat = 16,
+        CustomFormat1,
+        CustomFormat2,
+        CustomFormat3,
+        CustomFormat4,
+        CustomFormat5,
+        CustomFormat6,
+        CustomFormat7,
+        CustomFormat8,
+        CustomFormat9,
+        CustomFormat10,
+        CustomFormat11,
+        CustomFormat12,
+        CustomFormat13,
+        CustomFormat14,
+        CustomFormat15,
+        CustomFormat16
+    };
+    enum Scope {
+        UserScope,
+        SystemScope
+    };
+    explicit QSettings(const QString &organization,
+                       const QString &application = QString(), QObject *parent = 0);
+    QSettings(Scope scope, const QString &organization,
+              const QString &application = QString(), QObject *parent = 0);
+    QSettings(Format format, Scope scope, const QString &organization,
+       const QString &application = QString(), QObject *parent = 0);
+    QSettings(const QString &fileName, Format format, QObject *parent = 0);
+    explicit QSettings(QObject *parent = 0);
+    ~QSettings();
+    void clear();
+    void sync();
+    Status status() const;
+    void beginGroup(const QString &prefix);
+    void endGroup();
+    QString group() const;
+    int beginReadArray(const QString &prefix);
+    void beginWriteArray(const QString &prefix, int size = -1);
+    void endArray();
+    void setArrayIndex(int i);
+    QStringList allKeys() const;
+    QStringList childKeys() const;
+    QStringList childGroups() const;
+    bool isWritable() const;
+    void setValue(const QString &key, const QVariant &value);
+    QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+    void remove(const QString &key);
+    bool contains(const QString &key) const;
+    void setFallbacksEnabled(bool b);
+    bool fallbacksEnabled() const;
+    QString fileName() const;
+    Format format() const;
+    Scope scope() const;
+    QString organizationName() const;
+    QString applicationName() const;
+    void setIniCodec(QTextCodec *codec);
+    void setIniCodec(const char *codecName);
+    QTextCodec *iniCodec() const;
+    static void setDefaultFormat(Format format);
+    static Format defaultFormat();
+    static void setSystemIniPath(const QString &dir);
+    static void setUserIniPath(const QString &dir);
+    static void setPath(Format format, Scope scope, const QString &path);
+    typedef QMap<QString, QVariant> SettingsMap;
+    typedef bool (*ReadFunc)(QIODevice &device, SettingsMap &map);
+    typedef bool (*WriteFunc)(QIODevice &device, const SettingsMap &map);
+    static Format registerFormat(const QString &extension, ReadFunc readFunc, WriteFunc writeFunc,
+                                 Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive);
+protected:
+    bool event(QEvent *event);
+private:
+    QSettings(const QSettings &); QSettings &operator=(const QSettings &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTemporaryFilePrivate;
+class QTemporaryFile : public QFile
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QTemporaryFilePrivate* d_func() { return reinterpret_cast<QTemporaryFilePrivate *>(qGetPtrHelper(d_ptr)); } inline const QTemporaryFilePrivate* d_func() const { return reinterpret_cast<const QTemporaryFilePrivate *>(qGetPtrHelper(d_ptr)); } friend class QTemporaryFilePrivate;
+public:
+    QTemporaryFile();
+    explicit QTemporaryFile(const QString &templateName);
+    explicit QTemporaryFile(QObject *parent);
+    QTemporaryFile(const QString &templateName, QObject *parent);
+    ~QTemporaryFile();
+    bool autoRemove() const;
+    void setAutoRemove(bool b);
+    bool open() { return open(QIODevice::ReadWrite); }
+    QString fileName() const;
+    QString fileTemplate() const;
+    void setFileTemplate(const QString &name);
+    inline static QTemporaryFile *createLocalFile(const QString &fileName)
+        { QFile file(fileName); return createLocalFile(file); }
+    static QTemporaryFile *createLocalFile(QFile &file);
+    virtual QAbstractFileEngine *fileEngine() const;
+protected:
+    bool open(OpenMode flags);
+private:
+    friend class QFile;
+    QTemporaryFile(const QTemporaryFile &); QTemporaryFile &operator=(const QTemporaryFile &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QUrlPrivate;
+class QDataStream;
+class QMutexLocker;
+class QUrl
+{
+public:
+    enum ParsingMode {
+        TolerantMode,
+        StrictMode
+    };
+    enum FormattingOption {
+        None = 0x0,
+        RemoveScheme = 0x1,
+        RemovePassword = 0x2,
+        RemoveUserInfo = RemovePassword | 0x4,
+        RemovePort = 0x8,
+        RemoveAuthority = RemoveUserInfo | RemovePort | 0x10,
+        RemovePath = 0x20,
+        RemoveQuery = 0x40,
+        RemoveFragment = 0x80,
+        StripTrailingSlash = 0x10000
+    };
+    typedef QFlags<FormattingOption> FormattingOptions;
+    QUrl();
+    QUrl(const QString &url);
+    QUrl(const QString &url, ParsingMode mode);
+    QUrl(const QUrl &copy);
+    QUrl &operator =(const QUrl &copy);
+    QUrl &operator =(const QString &url);
+    ~QUrl();
+    inline void swap(QUrl &other) { qSwap(d, other.d); }
+    void setUrl(const QString &url);
+    void setUrl(const QString &url, ParsingMode mode);
+    void setEncodedUrl(const QByteArray &url);
+    void setEncodedUrl(const QByteArray &url, ParsingMode mode);
+    bool isValid() const;
+    bool isEmpty() const;
+    void clear();
+    void setScheme(const QString &scheme);
+    QString scheme() const;
+    void setAuthority(const QString &authority);
+    QString authority() const;
+    void setUserInfo(const QString &userInfo);
+    QString userInfo() const;
+    void setUserName(const QString &userName);
+    QString userName() const;
+    void setEncodedUserName(const QByteArray &userName);
+    QByteArray encodedUserName() const;
+    void setPassword(const QString &password);
+    QString password() const;
+    void setEncodedPassword(const QByteArray &password);
+    QByteArray encodedPassword() const;
+    void setHost(const QString &host);
+    QString host() const;
+    void setEncodedHost(const QByteArray &host);
+    QByteArray encodedHost() const;
+    void setPort(int port);
+    int port() const;
+    int port(int defaultPort) const;
+    void setPath(const QString &path);
+    QString path() const;
+    void setEncodedPath(const QByteArray &path);
+    QByteArray encodedPath() const;
+    bool hasQuery() const;
+    void setEncodedQuery(const QByteArray &query);
+    QByteArray encodedQuery() const;
+    void setQueryDelimiters(char valueDelimiter, char pairDelimiter);
+    char queryValueDelimiter() const;
+    char queryPairDelimiter() const;
+    void setQueryItems(const QList<QPair<QString, QString> > &query);
+    void addQueryItem(const QString &key, const QString &value);
+    QList<QPair<QString, QString> > queryItems() const;
+    bool hasQueryItem(const QString &key) const;
+    QString queryItemValue(const QString &key) const;
+    QStringList allQueryItemValues(const QString &key) const;
+    void removeQueryItem(const QString &key);
+    void removeAllQueryItems(const QString &key);
+    void setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query);
+    void addEncodedQueryItem(const QByteArray &key, const QByteArray &value);
+    QList<QPair<QByteArray, QByteArray> > encodedQueryItems() const;
+    bool hasEncodedQueryItem(const QByteArray &key) const;
+    QByteArray encodedQueryItemValue(const QByteArray &key) const;
+    QList<QByteArray> allEncodedQueryItemValues(const QByteArray &key) const;
+    void removeEncodedQueryItem(const QByteArray &key);
+    void removeAllEncodedQueryItems(const QByteArray &key);
+    void setFragment(const QString &fragment);
+    QString fragment() const;
+    void setEncodedFragment(const QByteArray &fragment);
+    QByteArray encodedFragment() const;
+    bool hasFragment() const;
+    QString topLevelDomain() const;
+    QUrl resolved(const QUrl &relative) const;
+    bool isRelative() const;
+    bool isParentOf(const QUrl &url) const;
+    static QUrl fromLocalFile(const QString &localfile);
+    QString toLocalFile() const;
+    bool isLocalFile() const;
+    QString toString(FormattingOptions options = None) const;
+    QByteArray toEncoded(FormattingOptions options = None) const;
+    static QUrl fromEncoded(const QByteArray &url);
+    static QUrl fromEncoded(const QByteArray &url, ParsingMode mode);
+    static QUrl fromUserInput(const QString &userInput);
+    void detach();
+    bool isDetached() const;
+    bool operator <(const QUrl &url) const;
+    bool operator ==(const QUrl &url) const;
+    bool operator !=(const QUrl &url) const;
+    static QString fromPercentEncoding(const QByteArray &);
+    static QByteArray toPercentEncoding(const QString &,
+                                        const QByteArray &exclude = QByteArray(),
+                                        const QByteArray &include = QByteArray());
+    static QString fromPunycode(const QByteArray &);
+    static QByteArray toPunycode(const QString &);
+    static QString fromAce(const QByteArray &);
+    static QByteArray toAce(const QString &);
+    static QStringList idnWhitelist();
+    static void setIdnWhitelist(const QStringList &);
+    QString errorString() const;
+protected:
+private:
+    void detach(QMutexLocker &locker);
+    QUrlPrivate *d;
+public:
+    typedef QUrlPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+inline uint qHash(const QUrl &url)
+{
+    return qHash(url.toEncoded(QUrl::FormattingOption(0x100)));
+}
+template<> class QTypeInfo<QUrl > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QUrl)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QUrl"; } };
+template <> inline bool qIsDetached<QUrl>(QUrl &t) { return t.isDetached(); } template <> inline void qSwap<QUrl>(QUrl &value1, QUrl &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QUrl>(::QUrl &value1, ::QUrl &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+ inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QUrl::FormattingOptions::enum_type f2) { return QFlags<QUrl::FormattingOptions::enum_type>(f1) | f2; } inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QFlags<QUrl::FormattingOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QUrl::FormattingOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ QDataStream &operator<<(QDataStream &, const QUrl &);
+ QDataStream &operator>>(QDataStream &, QUrl &);
+ QDebug operator<<(QDebug, const QUrl &);
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QEventLoopPrivate;
+class QEventLoop : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QEventLoopPrivate* d_func() { return reinterpret_cast<QEventLoopPrivate *>(qGetPtrHelper(d_ptr)); } inline const QEventLoopPrivate* d_func() const { return reinterpret_cast<const QEventLoopPrivate *>(qGetPtrHelper(d_ptr)); } friend class QEventLoopPrivate;
+public:
+    explicit QEventLoop(QObject *parent = 0);
+    ~QEventLoop();
+    enum ProcessEventsFlag {
+        AllEvents = 0x00,
+        ExcludeUserInputEvents = 0x01,
+        ExcludeSocketNotifiers = 0x02,
+        WaitForMoreEvents = 0x04,
+ X11ExcludeTimers = 0x08
+ , DeferredDeletion = 0x10
+        , EventLoopExec = 0x20
+        , DialogExec = 0x40
+    };
+    typedef QFlags<ProcessEventsFlag> ProcessEventsFlags;
+    bool processEvents(ProcessEventsFlags flags = AllEvents);
+    void processEvents(ProcessEventsFlags flags, int maximumTime);
+    int exec(ProcessEventsFlags flags = AllEvents);
+    void exit(int returnCode = 0);
+    bool isRunning() const;
+    void wakeUp();
+public :
+    void quit();
+};
+ inline QFlags<QEventLoop::ProcessEventsFlags::enum_type> operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QEventLoop::ProcessEventsFlags::enum_type f2) { return QFlags<QEventLoop::ProcessEventsFlags::enum_type>(f1) | f2; } inline QFlags<QEventLoop::ProcessEventsFlags::enum_type> operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QFlags<QEventLoop::ProcessEventsFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QEventLoop::ProcessEventsFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAbstractEventDispatcherPrivate;
+class QSocketNotifier;
+template <typename T1, typename T2> struct QPair;
+class QAbstractEventDispatcher : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QAbstractEventDispatcherPrivate* d_func() { return reinterpret_cast<QAbstractEventDispatcherPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractEventDispatcherPrivate* d_func() const { return reinterpret_cast<const QAbstractEventDispatcherPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractEventDispatcherPrivate;
+public:
+    typedef QPair<int, int> TimerInfo;
+    explicit QAbstractEventDispatcher(QObject *parent = 0);
+    ~QAbstractEventDispatcher();
+    static QAbstractEventDispatcher *instance(QThread *thread = 0);
+    virtual bool processEvents(QEventLoop::ProcessEventsFlags flags) = 0;
+    virtual bool hasPendingEvents() = 0;
+    virtual void registerSocketNotifier(QSocketNotifier *notifier) = 0;
+    virtual void unregisterSocketNotifier(QSocketNotifier *notifier) = 0;
+    int registerTimer(int interval, QObject *object);
+    virtual void registerTimer(int timerId, int interval, QObject *object) = 0;
+    virtual bool unregisterTimer(int timerId) = 0;
+    virtual bool unregisterTimers(QObject *object) = 0;
+    virtual QList<TimerInfo> registeredTimers(QObject *object) const = 0;
+    virtual void wakeUp() = 0;
+    virtual void interrupt() = 0;
+    virtual void flush() = 0;
+    virtual void startingUp();
+    virtual void closingDown();
+    typedef bool(*EventFilter)(void *message);
+    EventFilter setEventFilter(EventFilter filter);
+    bool filterEvent(void *message);
+protected:
+    void aboutToBlock();
+    void awake();
+protected:
+    QAbstractEventDispatcher(QAbstractEventDispatcherPrivate &,
+                             QObject *parent);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QAbstractItemModel;
+class QPersistentModelIndex;
+class QModelIndex
+{
+    friend class QAbstractItemModel;
+    friend class QProxyModel;
+public:
+    inline QModelIndex() : r(-1), c(-1), p(0), m(0) {}
+    inline QModelIndex(const QModelIndex &other)
+        : r(other.r), c(other.c), p(other.p), m(other.m) {}
+    inline ~QModelIndex() { p = 0; m = 0; }
+    inline int row() const { return r; }
+    inline int column() const { return c; }
+    inline void *internalPointer() const { return p; }
+    inline qint64 internalId() const { return reinterpret_cast<qint64>(p); }
+    inline QModelIndex parent() const;
+    inline QModelIndex sibling(int row, int column) const;
+    inline QModelIndex child(int row, int column) const;
+    inline QVariant data(int role = Qt::DisplayRole) const;
+    inline Qt::ItemFlags flags() const;
+    inline const QAbstractItemModel *model() const { return m; }
+    inline bool isValid() const { return (r >= 0) && (c >= 0) && (m != 0); }
+    inline bool operator==(const QModelIndex &other) const
+        { return (other.r == r) && (other.p == p) && (other.c == c) && (other.m == m); }
+    inline bool operator!=(const QModelIndex &other) const
+        { return !(*this == other); }
+    inline bool operator<(const QModelIndex &other) const
+        {
+          if (r < other.r) return true;
+          if (r == other.r) {
+              if (c < other.c) return true;
+              if (c == other.c) {
+                  if (p < other.p) return true;
+                  if (p == other.p) return m < other.m;
+              }
+          }
+          return false; }
+private:
+    inline QModelIndex(int row, int column, void *ptr, const QAbstractItemModel *model);
+    int r, c;
+    void *p;
+    const QAbstractItemModel *m;
+};
+template<> class QTypeInfo<QModelIndex > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QModelIndex)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QModelIndex"; } };
+ QDebug operator<<(QDebug, const QModelIndex &);
+class QPersistentModelIndexData;
+class QPersistentModelIndex
+{
+public:
+    QPersistentModelIndex();
+    QPersistentModelIndex(const QModelIndex &index);
+    QPersistentModelIndex(const QPersistentModelIndex &other);
+    ~QPersistentModelIndex();
+    bool operator<(const QPersistentModelIndex &other) const;
+    bool operator==(const QPersistentModelIndex &other) const;
+    inline bool operator!=(const QPersistentModelIndex &other) const
+    { return !operator==(other); }
+    QPersistentModelIndex &operator=(const QPersistentModelIndex &other);
+    bool operator==(const QModelIndex &other) const;
+    bool operator!=(const QModelIndex &other) const;
+    QPersistentModelIndex &operator=(const QModelIndex &other);
+    operator const QModelIndex&() const;
+    int row() const;
+    int column() const;
+    void *internalPointer() const;
+    qint64 internalId() const;
+    QModelIndex parent() const;
+    QModelIndex sibling(int row, int column) const;
+    QModelIndex child(int row, int column) const;
+    QVariant data(int role = Qt::DisplayRole) const;
+    Qt::ItemFlags flags() const;
+    const QAbstractItemModel *model() const;
+    bool isValid() const;
+private:
+    QPersistentModelIndexData *d;
+    friend uint qHash(const QPersistentModelIndex &);
+    friend QDebug operator<<(QDebug, const QPersistentModelIndex &);
+};
+template<> class QTypeInfo<QPersistentModelIndex > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPersistentModelIndex)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPersistentModelIndex"; } };
+inline uint qHash(const QPersistentModelIndex &index)
+{ return qHash(index.d); }
+ QDebug operator<<(QDebug, const QPersistentModelIndex &);
+template<typename T> class QList;
+typedef QList<QModelIndex> QModelIndexList;
+class QMimeData;
+class QAbstractItemModelPrivate;
+template <class Key, class T> class QMap;
+class QAbstractItemModel : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    friend class QPersistentModelIndexData;
+    friend class QAbstractItemViewPrivate;
+    friend class QIdentityProxyModel;
+public:
+    explicit QAbstractItemModel(QObject *parent = 0);
+    virtual ~QAbstractItemModel();
+    bool hasIndex(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    virtual QModelIndex index(int row, int column,
+                              const QModelIndex &parent = QModelIndex()) const = 0;
+    virtual QModelIndex parent(const QModelIndex &child) const = 0;
+    inline QModelIndex sibling(int row, int column, const QModelIndex &idx) const
+        { return index(row, column, parent(idx)); }
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const = 0;
+    virtual int columnCount(const QModelIndex &parent = QModelIndex()) const = 0;
+    virtual bool hasChildren(const QModelIndex &parent = QModelIndex()) const;
+    virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const = 0;
+    virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
+    virtual QVariant headerData(int section, Qt::Orientation orientation,
+                                int role = Qt::DisplayRole) const;
+    virtual bool setHeaderData(int section, Qt::Orientation orientation, const QVariant &value,
+                               int role = Qt::EditRole);
+    virtual QMap<int, QVariant> itemData(const QModelIndex &index) const;
+    virtual bool setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles);
+    virtual QStringList mimeTypes() const;
+    virtual QMimeData *mimeData(const QModelIndexList &indexes) const;
+    virtual bool dropMimeData(const QMimeData *data, Qt::DropAction action,
+                              int row, int column, const QModelIndex &parent);
+    virtual Qt::DropActions supportedDropActions() const;
+    Qt::DropActions supportedDragActions() const;
+    void setSupportedDragActions(Qt::DropActions);
+    virtual bool insertRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    virtual bool insertColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+    virtual bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    virtual bool removeColumns(int column, int count, const QModelIndex &parent = QModelIndex());
+    inline bool insertRow(int row, const QModelIndex &parent = QModelIndex());
+    inline bool insertColumn(int column, const QModelIndex &parent = QModelIndex());
+    inline bool removeRow(int row, const QModelIndex &parent = QModelIndex());
+    inline bool removeColumn(int column, const QModelIndex &parent = QModelIndex());
+    virtual void fetchMore(const QModelIndex &parent);
+    virtual bool canFetchMore(const QModelIndex &parent) const;
+    virtual Qt::ItemFlags flags(const QModelIndex &index) const;
+    virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);
+    virtual QModelIndex buddy(const QModelIndex &index) const;
+    virtual QModelIndexList match(const QModelIndex &start, int role,
+                                  const QVariant &value, int hits = 1,
+                                  Qt::MatchFlags flags =
+                                  Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap)) const;
+    virtual QSize span(const QModelIndex &index) const;
+    const QHash<int,QByteArray> &roleNames() const;
+    using QObject::parent;
+protected:
+    void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+    void headerDataChanged(Qt::Orientation orientation, int first, int last);
+    void layoutChanged();
+    void layoutAboutToBeChanged();
+private:
+    void rowsAboutToBeInserted(const QModelIndex &parent, int first, int last);
+    void rowsInserted(const QModelIndex &parent, int first, int last);
+    void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
+    void rowsRemoved(const QModelIndex &parent, int first, int last);
+    void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last);
+    void columnsInserted(const QModelIndex &parent, int first, int last);
+    void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
+    void columnsRemoved(const QModelIndex &parent, int first, int last);
+    void modelAboutToBeReset();
+    void modelReset();
+    void rowsAboutToBeMoved( const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow );
+    void rowsMoved( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row );
+    void columnsAboutToBeMoved( const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn );
+    void columnsMoved( const QModelIndex &parent, int start, int end, const QModelIndex &destination, int column );
+public :
+    virtual bool submit();
+    virtual void revert();
+protected:
+    QAbstractItemModel(QAbstractItemModelPrivate &dd, QObject *parent = 0);
+    inline QModelIndex createIndex(int row, int column, void *data = 0) const;
+    inline QModelIndex createIndex(int row, int column, int id) const;
+    inline QModelIndex createIndex(int row, int column, quint32 id) const;
+    void encodeData(const QModelIndexList &indexes, QDataStream &stream) const;
+    bool decodeData(int row, int column, const QModelIndex &parent, QDataStream &stream);
+    void beginInsertRows(const QModelIndex &parent, int first, int last);
+    void endInsertRows();
+    void beginRemoveRows(const QModelIndex &parent, int first, int last);
+    void endRemoveRows();
+    bool beginMoveRows(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationRow);
+    void endMoveRows();
+    void beginInsertColumns(const QModelIndex &parent, int first, int last);
+    void endInsertColumns();
+    void beginRemoveColumns(const QModelIndex &parent, int first, int last);
+    void endRemoveColumns();
+    bool beginMoveColumns(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationColumn);
+    void endMoveColumns();
+    void reset();
+    void beginResetModel();
+    void endResetModel();
+    void changePersistentIndex(const QModelIndex &from, const QModelIndex &to);
+    void changePersistentIndexList(const QModelIndexList &from, const QModelIndexList &to);
+    QModelIndexList persistentIndexList() const;
+    void setRoleNames(const QHash<int,QByteArray> &roleNames);
+protected :
+    void resetInternalData();
+private:
+    inline QAbstractItemModelPrivate* d_func() { return reinterpret_cast<QAbstractItemModelPrivate *>(qGetPtrHelper(d_ptr)); } inline const QAbstractItemModelPrivate* d_func() const { return reinterpret_cast<const QAbstractItemModelPrivate *>(qGetPtrHelper(d_ptr)); } friend class QAbstractItemModelPrivate;
+    QAbstractItemModel(const QAbstractItemModel &); QAbstractItemModel &operator=(const QAbstractItemModel &);
+};
+inline bool QAbstractItemModel::insertRow(int arow, const QModelIndex &aparent)
+{ return insertRows(arow, 1, aparent); }
+inline bool QAbstractItemModel::insertColumn(int acolumn, const QModelIndex &aparent)
+{ return insertColumns(acolumn, 1, aparent); }
+inline bool QAbstractItemModel::removeRow(int arow, const QModelIndex &aparent)
+{ return removeRows(arow, 1, aparent); }
+inline bool QAbstractItemModel::removeColumn(int acolumn, const QModelIndex &aparent)
+{ return removeColumns(acolumn, 1, aparent); }
+inline QModelIndex QAbstractItemModel::createIndex(int arow, int acolumn, void *adata) const
+{ return QModelIndex(arow, acolumn, adata, this); }
+inline QModelIndex QAbstractItemModel::createIndex(int arow, int acolumn, int aid) const
+{ return QModelIndex(arow, acolumn, reinterpret_cast<void*>(aid), this); }
+inline QModelIndex QAbstractItemModel::createIndex(int arow, int acolumn, quint32 aid) const
+{ return QModelIndex(arow, acolumn, reinterpret_cast<void*>(aid), this); }
+class QAbstractTableModel : public QAbstractItemModel
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QAbstractTableModel(QObject *parent = 0);
+    ~QAbstractTableModel();
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    bool dropMimeData(const QMimeData *data, Qt::DropAction action,
+                      int row, int column, const QModelIndex &parent);
+protected:
+    QAbstractTableModel(QAbstractItemModelPrivate &dd, QObject *parent);
+private:
+    QAbstractTableModel(const QAbstractTableModel &); QAbstractTableModel &operator=(const QAbstractTableModel &);
+    QModelIndex parent(const QModelIndex &child) const;
+    bool hasChildren(const QModelIndex &parent) const;
+};
+class QAbstractListModel : public QAbstractItemModel
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QAbstractListModel(QObject *parent = 0);
+    ~QAbstractListModel();
+    QModelIndex index(int row, int column = 0, const QModelIndex &parent = QModelIndex()) const;
+    bool dropMimeData(const QMimeData *data, Qt::DropAction action,
+                      int row, int column, const QModelIndex &parent);
+protected:
+    QAbstractListModel(QAbstractItemModelPrivate &dd, QObject *parent);
+private:
+    QAbstractListModel(const QAbstractListModel &); QAbstractListModel &operator=(const QAbstractListModel &);
+    QModelIndex parent(const QModelIndex &child) const;
+    int columnCount(const QModelIndex &parent) const;
+    bool hasChildren(const QModelIndex &parent) const;
+};
+inline QModelIndex::QModelIndex(int arow, int acolumn, void *adata,
+                                const QAbstractItemModel *amodel)
+    : r(arow), c(acolumn), p(adata), m(amodel) {}
+inline QModelIndex QModelIndex::parent() const
+{ return m ? m->parent(*this) : QModelIndex(); }
+inline QModelIndex QModelIndex::sibling(int arow, int acolumn) const
+{ return m ? (r == arow && c == acolumn) ? *this : m->index(arow, acolumn, m->parent(*this)) : QModelIndex(); }
+inline QModelIndex QModelIndex::child(int arow, int acolumn) const
+{ return m ? m->index(arow, acolumn, *this) : QModelIndex(); }
+inline QVariant QModelIndex::data(int arole) const
+{ return m ? m->data(*this, arole) : QVariant(); }
+inline Qt::ItemFlags QModelIndex::flags() const
+{ return m ? m->flags(*this) : Qt::ItemFlags(0); }
+inline uint qHash(const QModelIndex &index)
+{ return uint((index.row() << 4) + index.column() + index.internalId()); }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QObject;
+class QBasicTimer
+{
+    int id;
+public:
+    inline QBasicTimer() : id(0) {}
+    inline ~QBasicTimer() { if (id) stop(); }
+    inline bool isActive() const { return id != 0; }
+    inline int timerId() const { return id; }
+    void start(int msec, QObject *obj);
+    void stop();
+};
+template<> class QTypeInfo<QBasicTimer > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QBasicTimer)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QBasicTimer"; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QCoreApplicationPrivate;
+class QTextCodec;
+class QTranslator;
+class QPostEventList;
+class QStringList;
+class QCoreApplication : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QCoreApplicationPrivate* d_func() { return reinterpret_cast<QCoreApplicationPrivate *>(qGetPtrHelper(d_ptr)); } inline const QCoreApplicationPrivate* d_func() const { return reinterpret_cast<const QCoreApplicationPrivate *>(qGetPtrHelper(d_ptr)); } friend class QCoreApplicationPrivate;
+public:
+    enum { ApplicationFlags = 0x040804
+        | 0x01000000
+    };
+    QCoreApplication(int &argc, char **argv, int
+        = ApplicationFlags
+        );
+    ~QCoreApplication();
+    static int argc();
+    static char **argv();
+    static QStringList arguments();
+    static void setAttribute(Qt::ApplicationAttribute attribute, bool on = true);
+    static bool testAttribute(Qt::ApplicationAttribute attribute);
+    static void setOrganizationDomain(const QString &orgDomain);
+    static QString organizationDomain();
+    static void setOrganizationName(const QString &orgName);
+    static QString organizationName();
+    static void setApplicationName(const QString &application);
+    static QString applicationName();
+    static void setApplicationVersion(const QString &version);
+    static QString applicationVersion();
+    static QCoreApplication *instance() { return self; }
+    static int exec();
+    static void processEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents);
+    static void processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime);
+    static void exit(int retcode=0);
+    static bool sendEvent(QObject *receiver, QEvent *event);
+    static void postEvent(QObject *receiver, QEvent *event);
+    static void postEvent(QObject *receiver, QEvent *event, int priority);
+    static void sendPostedEvents(QObject *receiver, int event_type);
+    static void sendPostedEvents();
+    static void removePostedEvents(QObject *receiver);
+    static void removePostedEvents(QObject *receiver, int eventType);
+    static bool hasPendingEvents();
+    virtual bool notify(QObject *, QEvent *);
+    static bool startingUp();
+    static bool closingDown();
+    static QString applicationDirPath();
+    static QString applicationFilePath();
+    static qint64 applicationPid();
+    static void setLibraryPaths(const QStringList &);
+    static QStringList libraryPaths();
+    static void addLibraryPath(const QString &);
+    static void removeLibraryPath(const QString &);
+    static void installTranslator(QTranslator * messageFile);
+    static void removeTranslator(QTranslator * messageFile);
+    enum Encoding { CodecForTr, UnicodeUTF8, DefaultCodec = CodecForTr };
+    static QString translate(const char * context,
+                             const char * key,
+                             const char * disambiguation = 0,
+                             Encoding encoding = CodecForTr);
+    static QString translate(const char * context,
+                             const char * key,
+                             const char * disambiguation,
+                             Encoding encoding, int n);
+    static void flush();
+    static void watchUnixSignal(int signal, bool watch);
+    typedef bool (*EventFilter)(void *message, long *result);
+    EventFilter setEventFilter(EventFilter filter);
+    bool filterEvent(void *message, long *result);
+public :
+    static void quit();
+protected:
+    void aboutToQuit();
+    void unixSignal(int);
+protected:
+    bool event(QEvent *);
+    virtual bool compressEvent(QEvent *, QObject *receiver, QPostEventList *);
+protected:
+    QCoreApplication(QCoreApplicationPrivate &p);
+private:
+    static bool sendSpontaneousEvent(QObject *receiver, QEvent *event);
+    bool notifyInternal(QObject *receiver, QEvent *event);
+    void init();
+    static QCoreApplication *self;
+    QCoreApplication(const QCoreApplication &); QCoreApplication &operator=(const QCoreApplication &);
+    friend class QEventDispatcherUNIXPrivate;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class QETWidget;
+    friend class Q3AccelManager;
+    friend class QShortcutMap;
+    friend class QWidget;
+    friend class QWidgetPrivate;
+    friend bool qt_sendSpontaneousEvent(QObject*, QEvent*);
+    friend QString qAppName();
+    friend class QClassFactory;
+};
+inline bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event)
+{ if (event) event->spont = false; return self ? self->notifyInternal(receiver, event) : false; }
+inline bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event)
+{ if (event) event->spont = true; return self ? self->notifyInternal(receiver, event) : false; }
+inline void QCoreApplication::sendPostedEvents() { sendPostedEvents(0, 0); }
+typedef void (*QtCleanUpFunction)();
+ void qAddPostRoutine(QtCleanUpFunction);
+ void qRemovePostRoutine(QtCleanUpFunction);
+ QString qAppName();
+extern "C" {
+typedef float float_t;
+typedef double double_t;
+extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
+extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
+extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
+extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
+extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
+extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
+extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
+extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
+extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
+extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
+extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
+                                                           ;
+extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
+extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
+extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
+extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
+extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
+extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
+extern double log (double __x) throw (); extern double __log (double __x) throw ();
+extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
+extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ()
+     __attribute__ ((__nonnull__ (2)));
+extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
+extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
+extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
+extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
+extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
+extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
+extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
+extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
+extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
+extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
+extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
+extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
+extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
+extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
+extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
+extern int __isinf (double __value) throw () __attribute__ ((__const__));
+extern int __finite (double __value) throw () __attribute__ ((__const__));
+extern int isinf (double __value) throw () __attribute__ ((__const__));
+extern int finite (double __value) throw () __attribute__ ((__const__));
+extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
+extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
+extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
+extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));
+extern int __isnan (double __value) throw () __attribute__ ((__const__));
+extern int isnan (double __value) throw () __attribute__ ((__const__));
+extern double j0 (double) throw (); extern double __j0 (double) throw ();
+extern double j1 (double) throw (); extern double __j1 (double) throw ();
+extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
+extern double y0 (double) throw (); extern double __y0 (double) throw ();
+extern double y1 (double) throw (); extern double __y1 (double) throw ();
+extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
+extern double erf (double) throw (); extern double __erf (double) throw ();
+extern double erfc (double) throw (); extern double __erfc (double) throw ();
+extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
+extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
+extern double gamma (double) throw (); extern double __gamma (double) throw ();
+extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
+extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
+extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
+extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
+extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
+extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
+extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
+extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
+extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
+extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
+extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
+extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
+extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
+extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
+extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
+extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
+extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
+extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();
+extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();
+extern int __fpclassify (double __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbit (double __value) throw ()
+     __attribute__ ((__const__));
+extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
+extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
+extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
+extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
+extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
+extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
+extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
+extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
+extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
+extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
+extern void
+ sincosf
+ (float __x, float *__sinx, float *__cosx) throw (); extern void
+ __sincosf
+ (float __x, float *__sinx, float *__cosx) throw ()
+                                                           ;
+extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
+extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
+extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
+extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
+extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
+extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
+extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
+extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
+extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ()
+     __attribute__ ((__nonnull__ (2)));
+extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
+extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
+extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
+extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
+extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
+extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
+extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
+extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
+extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
+extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
+extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
+extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
+extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
+extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
+extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
+extern int __isinff (float __value) throw () __attribute__ ((__const__));
+extern int __finitef (float __value) throw () __attribute__ ((__const__));
+extern int isinff (float __value) throw () __attribute__ ((__const__));
+extern int finitef (float __value) throw () __attribute__ ((__const__));
+extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
+extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
+extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));
+extern int __isnanf (float __value) throw () __attribute__ ((__const__));
+extern int isnanf (float __value) throw () __attribute__ ((__const__));
+extern float j0f (float) throw (); extern float __j0f (float) throw ();
+extern float j1f (float) throw (); extern float __j1f (float) throw ();
+extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
+extern float y0f (float) throw (); extern float __y0f (float) throw ();
+extern float y1f (float) throw (); extern float __y1f (float) throw ();
+extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
+extern float erff (float) throw (); extern float __erff (float) throw ();
+extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
+extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
+extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
+extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
+extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
+extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
+extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
+extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
+extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
+extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
+extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
+extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
+extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
+extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
+extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
+extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
+extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
+extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
+extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
+extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
+extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();
+extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();
+extern int __fpclassifyf (float __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbitf (float __value) throw ()
+     __attribute__ ((__const__));
+extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
+extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
+extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
+extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
+extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
+extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
+extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
+extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
+extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
+extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
+extern void
+ sincosl
+ (long double __x, long double *__sinx, long double *__cosx) throw (); extern void
+ __sincosl
+ (long double __x, long double *__sinx, long double *__cosx) throw ()
+                                                           ;
+extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
+extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
+extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
+extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
+extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
+extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
+extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
+extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
+extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ()
+     __attribute__ ((__nonnull__ (2)));
+extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
+extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
+extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
+extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
+extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
+extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
+extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
+extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
+extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
+extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
+extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
+extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
+extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
+extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
+extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
+extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
+extern int __finitel (long double __value) throw () __attribute__ ((__const__));
+extern int isinfl (long double __value) throw () __attribute__ ((__const__));
+extern int finitel (long double __value) throw () __attribute__ ((__const__));
+extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
+extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
+extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));
+extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
+extern int isnanl (long double __value) throw () __attribute__ ((__const__));
+extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
+extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
+extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
+extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
+extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
+extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
+extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
+extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
+extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
+extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
+extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
+extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
+extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
+extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
+extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
+extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
+extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
+extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
+extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
+extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
+extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
+extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
+extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
+extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
+extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
+extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
+extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();
+extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();
+extern int __fpclassifyl (long double __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbitl (long double __value) throw ()
+     __attribute__ ((__const__));
+extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+extern int signgam;
+enum
+  {
+    FP_NAN,
+    FP_INFINITE,
+    FP_ZERO,
+    FP_SUBNORMAL,
+    FP_NORMAL
+  };
+typedef enum
+{
+  _IEEE_ = -1,
+  _SVID_,
+  _XOPEN_,
+  _POSIX_,
+  _ISOC_
+} _LIB_VERSION_TYPE;
+extern _LIB_VERSION_TYPE _LIB_VERSION;
+struct __exception
+  {
+    int type;
+    char *name;
+    double arg1;
+    double arg2;
+    double retval;
+  };
+extern int matherr (struct __exception *__exc) throw ();
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) __signbitf (float __x) throw ()
+{
+  __extension__ union { float __f; int __i; } __u = { __f: __x };
+  return __u.__i < 0;
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) __signbit (double __x) throw ()
+{
+  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
+  return __u.__i[0] < 0;
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
+{
+  __extension__ union { long double __d; int __i[4]; } __u = { __d: __x };
+  return __u.__i[0] < 0;
+}
+extern __inline __attribute__ ((__gnu_inline__)) double fdim (double __x, double __y) throw ();
+extern __inline __attribute__ ((__gnu_inline__)) double
+__attribute__ ((__leaf__)) fdim (double __x, double __y) throw ()
+{
+  return __x <= __y ? 0 : __x - __y;
+}
+extern __inline __attribute__ ((__gnu_inline__)) float fdimf (float __x, float __y) throw ();
+extern __inline __attribute__ ((__gnu_inline__)) float
+__attribute__ ((__leaf__)) fdimf (float __x, float __y) throw ()
+{
+  return __x <= __y ? 0 : __x - __y;
+}
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+extern const qreal qt_sine_table[256];
+inline int qCeil(qreal v)
+{
+    if (sizeof(qreal) == sizeof(float))
+        return int(ceilf(float(v)));
+    else
+        return int(ceil(v));
+}
+inline int qFloor(qreal v)
+{
+    if (sizeof(qreal) == sizeof(float))
+        return int(floorf(float(v)));
+    else
+        return int(floor(v));
+}
+inline qreal qFabs(qreal v)
+{
+    if(sizeof(qreal) == sizeof(float))
+        return fabsf(float(v));
+    else
+        return fabs(v);
+}
+inline qreal qSin(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return sinf(float(v));
+        else
+            return sin(v);
+}
+inline qreal qCos(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return cosf(float(v));
+        else
+            return cos(v);
+}
+inline qreal qTan(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return tanf(float(v));
+        else
+            return tan(v);
+}
+inline qreal qAcos(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return acosf(float(v));
+        else
+           return acos(v);
+}
+inline qreal qAsin(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return asinf(float(v));
+        else
+            return asin(v);
+}
+inline qreal qAtan(qreal v)
+{
+        if(sizeof(qreal) == sizeof(float))
+            return atanf(float(v));
+        else
+            return atan(v);
+}
+inline qreal qAtan2(qreal x, qreal y)
+{
+        if(sizeof(qreal) == sizeof(float))
+            return atan2f(float(x), float(y));
+        else
+            return atan2(x, y);
+}
+inline qreal qSqrt(qreal v)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return sqrtf(float(v));
+        else
+            return sqrt(v);
+}
+inline qreal qLn(qreal v)
+{
+    if (sizeof(qreal) == sizeof(float))
+        return logf(float(v));
+    else
+        return log(v);
+}
+inline qreal qExp(qreal v)
+{
+    return exp(v);
+}
+inline qreal qPow(qreal x, qreal y)
+{
+        if (sizeof(qreal) == sizeof(float))
+            return powf(float(x), float(y));
+        else
+            return pow(x, y);
+}
+inline qreal qFastSin(qreal x)
+{
+    int si = int(x * (0.5 * 256 / 3.14159265358979323846));
+    qreal d = x - si * (2.0 * 3.14159265358979323846 / 256);
+    int ci = si + 256 / 4;
+    si &= 256 - 1;
+    ci &= 256 - 1;
+    return qt_sine_table[si] + (qt_sine_table[ci] - 0.5 * qt_sine_table[si] * d) * d;
+}
+inline qreal qFastCos(qreal x)
+{
+    int ci = int(x * (0.5 * 256 / 3.14159265358979323846));
+    qreal d = x - ci * (2.0 * 3.14159265358979323846 / 256);
+    int si = ci + 256 / 4;
+    si &= 256 - 1;
+    ci &= 256 - 1;
+    return qt_sine_table[si] - (qt_sine_table[ci] + 0.5 * qt_sine_table[si] * d) * d;
+}
+typedef QtValidLicenseForCoreModule QtCoreModule;
+template <typename T> class QList;
+class QMetaMethod
+{
+public:
+    inline QMetaMethod() : mobj(0),handle(0) {}
+    const char *signature() const;
+    const char *typeName() const;
+    QList<QByteArray> parameterTypes() const;
+    QList<QByteArray> parameterNames() const;
+    const char *tag() const;
+    enum Access { Private, Protected, Public };
+    Access access() const;
+    enum MethodType { Method, Signal, Slot, Constructor };
+    MethodType methodType() const;
+    enum Attributes { Compatibility = 0x1, Cloned = 0x2, Scriptable = 0x4 };
+    int attributes() const;
+    int methodIndex() const;
+    int revision() const;
+    inline const QMetaObject *enclosingMetaObject() const { return mobj; }
+    bool invoke(QObject *object,
+                Qt::ConnectionType connectionType,
+                QGenericReturnArgument returnValue,
+                QGenericArgument val0 = QGenericArgument(0),
+                QGenericArgument val1 = QGenericArgument(),
+                QGenericArgument val2 = QGenericArgument(),
+                QGenericArgument val3 = QGenericArgument(),
+                QGenericArgument val4 = QGenericArgument(),
+                QGenericArgument val5 = QGenericArgument(),
+                QGenericArgument val6 = QGenericArgument(),
+                QGenericArgument val7 = QGenericArgument(),
+                QGenericArgument val8 = QGenericArgument(),
+                QGenericArgument val9 = QGenericArgument()) const;
+    inline bool invoke(QObject *object,
+                       QGenericReturnArgument returnValue,
+                       QGenericArgument val0 = QGenericArgument(0),
+                       QGenericArgument val1 = QGenericArgument(),
+                       QGenericArgument val2 = QGenericArgument(),
+                       QGenericArgument val3 = QGenericArgument(),
+                       QGenericArgument val4 = QGenericArgument(),
+                       QGenericArgument val5 = QGenericArgument(),
+                       QGenericArgument val6 = QGenericArgument(),
+                       QGenericArgument val7 = QGenericArgument(),
+                       QGenericArgument val8 = QGenericArgument(),
+                       QGenericArgument val9 = QGenericArgument()) const
+    {
+        return invoke(object, Qt::AutoConnection, returnValue,
+                      val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
+    }
+    inline bool invoke(QObject *object,
+                       Qt::ConnectionType connectionType,
+                       QGenericArgument val0 = QGenericArgument(0),
+                       QGenericArgument val1 = QGenericArgument(),
+                       QGenericArgument val2 = QGenericArgument(),
+                       QGenericArgument val3 = QGenericArgument(),
+                       QGenericArgument val4 = QGenericArgument(),
+                       QGenericArgument val5 = QGenericArgument(),
+                       QGenericArgument val6 = QGenericArgument(),
+                       QGenericArgument val7 = QGenericArgument(),
+                       QGenericArgument val8 = QGenericArgument(),
+                       QGenericArgument val9 = QGenericArgument()) const
+    {
+        return invoke(object, connectionType, QGenericReturnArgument(),
+                      val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
+    }
+    inline bool invoke(QObject *object,
+                       QGenericArgument val0 = QGenericArgument(0),
+                       QGenericArgument val1 = QGenericArgument(),
+                       QGenericArgument val2 = QGenericArgument(),
+                       QGenericArgument val3 = QGenericArgument(),
+                       QGenericArgument val4 = QGenericArgument(),
+                       QGenericArgument val5 = QGenericArgument(),
+                       QGenericArgument val6 = QGenericArgument(),
+                       QGenericArgument val7 = QGenericArgument(),
+                       QGenericArgument val8 = QGenericArgument(),
+                       QGenericArgument val9 = QGenericArgument()) const
+    {
+        return invoke(object, Qt::AutoConnection, QGenericReturnArgument(),
+                      val0, val1, val2, val3, val4, val5, val6, val7, val8, val9);
+    }
+private:
+    const QMetaObject *mobj;
+    uint handle;
+    friend struct QMetaObject;
+    friend struct QMetaObjectPrivate;
+    friend class QObject;
+};
+template<> class QTypeInfo<QMetaMethod > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMetaMethod)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMetaMethod"; } };
+class QMetaEnum
+{
+public:
+    inline QMetaEnum() : mobj(0),handle(0) {}
+    const char *name() const;
+    bool isFlag() const;
+    int keyCount() const;
+    const char *key(int index) const;
+    int value(int index) const;
+    const char *scope() const;
+    int keyToValue(const char *key) const;
+    const char* valueToKey(int value) const;
+    int keysToValue(const char * keys) const;
+    QByteArray valueToKeys(int value) const;
+    inline const QMetaObject *enclosingMetaObject() const { return mobj; }
+    inline bool isValid() const { return name() != 0; }
+private:
+    const QMetaObject *mobj;
+    uint handle;
+    friend struct QMetaObject;
+};
+template<> class QTypeInfo<QMetaEnum > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMetaEnum)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMetaEnum"; } };
+class QMetaProperty
+{
+public:
+    QMetaProperty();
+    const char *name() const;
+    const char *typeName() const;
+    QVariant::Type type() const;
+    int userType() const;
+    int propertyIndex() const;
+    bool isReadable() const;
+    bool isWritable() const;
+    bool isResettable() const;
+    bool isDesignable(const QObject *obj = 0) const;
+    bool isScriptable(const QObject *obj = 0) const;
+    bool isStored(const QObject *obj = 0) const;
+    bool isEditable(const QObject *obj = 0) const;
+    bool isUser(const QObject *obj = 0) const;
+    bool isConstant() const;
+    bool isFinal() const;
+    bool isFlagType() const;
+    bool isEnumType() const;
+    QMetaEnum enumerator() const;
+    bool hasNotifySignal() const;
+    QMetaMethod notifySignal() const;
+    int notifySignalIndex() const;
+    int revision() const;
+    QVariant read(const QObject *obj) const;
+    bool write(QObject *obj, const QVariant &value) const;
+    bool reset(QObject *obj) const;
+    bool hasStdCppSet() const;
+    inline bool isValid() const { return isReadable(); }
+    inline const QMetaObject *enclosingMetaObject() const { return mobj; }
+private:
+    const QMetaObject *mobj;
+    uint handle;
+    int idx;
+    QMetaEnum menum;
+    friend struct QMetaObject;
+};
+class QMetaClassInfo
+{
+public:
+    inline QMetaClassInfo() : mobj(0),handle(0) {}
+    const char *name() const;
+    const char *value() const;
+    inline const QMetaObject *enclosingMetaObject() const { return mobj; }
+private:
+    const QMetaObject *mobj;
+    uint handle;
+    friend struct QMetaObject;
+};
+template<> class QTypeInfo<QMetaClassInfo > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMetaClassInfo)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMetaClassInfo"; } };
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QUrl;
+class QMimeDataPrivate;
+class QMimeData : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QMimeData();
+    ~QMimeData();
+    QList<QUrl> urls() const;
+    void setUrls(const QList<QUrl> &urls);
+    bool hasUrls() const;
+    QString text() const;
+    void setText(const QString &text);
+    bool hasText() const;
+    QString html() const;
+    void setHtml(const QString &html);
+    bool hasHtml() const;
+    QVariant imageData() const;
+    void setImageData(const QVariant &image);
+    bool hasImage() const;
+    QVariant colorData() const;
+    void setColorData(const QVariant &color);
+    bool hasColor() const;
+    QByteArray data(const QString &mimetype) const;
+    void setData(const QString &mimetype, const QByteArray &data);
+    void removeFormat(const QString &mimetype);
+    virtual bool hasFormat(const QString &mimetype) const;
+    virtual QStringList formats() const;
+    void clear();
+protected:
+    virtual QVariant retrieveData(const QString &mimetype,
+                                      QVariant::Type preferredType) const;
+private:
+    QMimeData(const QMimeData &); QMimeData &operator=(const QMimeData &);
+    inline QMimeDataPrivate* d_func() { return reinterpret_cast<QMimeDataPrivate *>(qGetPtrHelper(d_ptr)); } inline const QMimeDataPrivate* d_func() const { return reinterpret_cast<const QMimeDataPrivate *>(qGetPtrHelper(d_ptr)); } friend class QMimeDataPrivate;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QObjectCleanupHandler : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    QObjectCleanupHandler();
+    ~QObjectCleanupHandler();
+    QObject* add(QObject* object);
+    void remove(QObject *object);
+    bool isEmpty() const;
+    void clear();
+private:
+    QObjectList cleanupObjects;
+private :
+    void objectDestroyed(QObject *);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSharedMemoryPrivate;
+class QSharedMemory : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QSharedMemoryPrivate* d_func() { return reinterpret_cast<QSharedMemoryPrivate *>(qGetPtrHelper(d_ptr)); } inline const QSharedMemoryPrivate* d_func() const { return reinterpret_cast<const QSharedMemoryPrivate *>(qGetPtrHelper(d_ptr)); } friend class QSharedMemoryPrivate;
+public:
+    enum AccessMode
+    {
+        ReadOnly,
+        ReadWrite
+    };
+    enum SharedMemoryError
+    {
+        NoError,
+        PermissionDenied,
+        InvalidSize,
+        KeyError,
+        AlreadyExists,
+        NotFound,
+        LockError,
+        OutOfResources,
+        UnknownError
+    };
+    QSharedMemory(QObject *parent = 0);
+    QSharedMemory(const QString &key, QObject *parent = 0);
+    ~QSharedMemory();
+    void setKey(const QString &key);
+    QString key() const;
+    void setNativeKey(const QString &key);
+    QString nativeKey() const;
+    bool create(int size, AccessMode mode = ReadWrite);
+    int size() const;
+    bool attach(AccessMode mode = ReadWrite);
+    bool isAttached() const;
+    bool detach();
+    void *data();
+    const void* constData() const;
+    const void *data() const;
+    bool lock();
+    bool unlock();
+    SharedMemoryError error() const;
+    QString errorString() const;
+private:
+    QSharedMemory(const QSharedMemory &); QSharedMemory &operator=(const QSharedMemory &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSignalMapperPrivate;
+class QSignalMapper : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QSignalMapperPrivate* d_func() { return reinterpret_cast<QSignalMapperPrivate *>(qGetPtrHelper(d_ptr)); } inline const QSignalMapperPrivate* d_func() const { return reinterpret_cast<const QSignalMapperPrivate *>(qGetPtrHelper(d_ptr)); } friend class QSignalMapperPrivate;
+public:
+    explicit QSignalMapper(QObject *parent = 0);
+    ~QSignalMapper();
+    void setMapping(QObject *sender, int id);
+    void setMapping(QObject *sender, const QString &text);
+    void setMapping(QObject *sender, QWidget *widget);
+    void setMapping(QObject *sender, QObject *object);
+    void removeMappings(QObject *sender);
+    QObject *mapping(int id) const;
+    QObject *mapping(const QString &text) const;
+    QObject *mapping(QWidget *widget) const;
+    QObject *mapping(QObject *object) const;
+protected:
+    void mapped(int);
+    void mapped(const QString &);
+    void mapped(QWidget *);
+    void mapped(QObject *);
+public :
+    void map();
+    void map(QObject *sender);
+private:
+    QSignalMapper(const QSignalMapper &); QSignalMapper &operator=(const QSignalMapper &);
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSocketNotifier : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate;
+public:
+    enum Type { Read, Write, Exception };
+    QSocketNotifier(int socket, Type, QObject *parent = 0);
+    ~QSocketNotifier();
+    inline int socket() const { return sockfd; }
+    inline Type type() const { return sntype; }
+    inline bool isEnabled() const { return snenabled; }
+public :
+    void setEnabled(bool);
+protected:
+    void activated(int socket);
+protected:
+    bool event(QEvent *);
+private:
+    QSocketNotifier(const QSocketNotifier &); QSocketNotifier &operator=(const QSocketNotifier &);
+    int sockfd;
+    Type sntype;
+    bool snenabled;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QSystemSemaphorePrivate;
+class QSystemSemaphore
+{
+public:
+    enum AccessMode
+    {
+        Open,
+        Create
+    };
+    enum SystemSemaphoreError
+    {
+        NoError,
+        PermissionDenied,
+        KeyError,
+        AlreadyExists,
+        NotFound,
+        OutOfResources,
+        UnknownError
+    };
+    QSystemSemaphore(const QString &key, int initialValue = 0, AccessMode mode = Open);
+    ~QSystemSemaphore();
+    void setKey(const QString &key, int initialValue = 0, AccessMode mode = Open);
+    QString key() const;
+    bool acquire();
+    bool release(int n = 1);
+    SystemSemaphoreError error() const;
+    QString errorString() const;
+private:
+    QSystemSemaphore(const QSystemSemaphore &); QSystemSemaphore &operator=(const QSystemSemaphore &);
+    QScopedPointer<QSystemSemaphorePrivate> d;
+};
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QTimer : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QTimer(QObject *parent = 0);
+    ~QTimer();
+    inline bool isActive() const { return id >= 0; }
+    int timerId() const { return id; }
+    void setInterval(int msec);
+    int interval() const { return inter; }
+    inline void setSingleShot(bool singleShot);
+    inline bool isSingleShot() const { return single; }
+    static void singleShot(int msec, QObject *receiver, const char *member);
+public :
+    void start(int msec);
+    void start();
+    void stop();
+protected:
+    void timeout();
+protected:
+    void timerEvent(QTimerEvent *);
+private:
+    QTimer(const QTimer &); QTimer &operator=(const QTimer &);
+    inline int startTimer(int){ return -1;}
+    inline void killTimer(int){}
+    int id, inter, del;
+    uint single : 1;
+    uint nulltimer : 1;
+};
+inline void QTimer::setSingleShot(bool asingleShot) { single = asingleShot; }
+typedef QtValidLicenseForCoreModule QtCoreModule;
+class QLocale;
+class QTranslatorPrivate;
+class QTranslator : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QTranslator(QObject *parent = 0);
+    ~QTranslator();
+    virtual QString translate(const char *context, const char *sourceText,
+                              const char *disambiguation = 0) const;
+    QString translate(const char *context, const char *sourceText, const char *disambiguation,
+                      int n) const;
+    virtual bool isEmpty() const;
+    bool load(const QString & filename,
+              const QString & directory = QString(),
+              const QString & search_delimiters = QString(),
+              const QString & suffix = QString());
+    bool load(const QLocale & locale,
+              const QString & filename,
+              const QString & prefix = QString(),
+              const QString & directory = QString(),
+              const QString & suffix = QString());
+    bool load(const uchar *data, int len);
+private:
+    QTranslator(const QTranslator &); QTranslator &operator=(const QTranslator &);
+    inline QTranslatorPrivate* d_func() { return reinterpret_cast<QTranslatorPrivate *>(qGetPtrHelper(d_ptr)); } inline const QTranslatorPrivate* d_func() const { return reinterpret_cast<const QTranslatorPrivate *>(qGetPtrHelper(d_ptr)); } friend class QTranslatorPrivate;
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptEngine;
+class QScriptContext;
+class QScriptValue;
+class QScriptablePrivate;
+class QScriptable
+{
+public:
+    QScriptable();
+    ~QScriptable();
+    QScriptEngine *engine() const;
+    QScriptContext *context() const;
+    QScriptValue thisObject() const;
+    int argumentCount() const;
+    QScriptValue argument(int index) const;
+private:
+    QScopedPointer<QScriptablePrivate> d_ptr;
+    QScriptable(const QScriptable &); QScriptable &operator=(const QScriptable &);
+    inline QScriptablePrivate* d_func() { return reinterpret_cast<QScriptablePrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptablePrivate* d_func() const { return reinterpret_cast<const QScriptablePrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptablePrivate;
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptClass;
+class QScriptValue;
+class QScriptEngine;
+class QScriptString;
+class QVariant;
+class QObject;
+struct QMetaObject;
+class QDateTime;
+class QRegExp;
+typedef QList<QScriptValue> QScriptValueList;
+typedef double qsreal;
+class QScriptValuePrivate;
+class QScriptEnginePrivate;
+struct QScriptValuePrivatePointerDeleter;
+class QScriptValue
+{
+public:
+    enum ResolveFlag {
+        ResolveLocal = 0x00,
+        ResolvePrototype = 0x01,
+        ResolveScope = 0x02,
+        ResolveFull = ResolvePrototype | ResolveScope
+    };
+    typedef QFlags<ResolveFlag> ResolveFlags;
+    enum PropertyFlag {
+        ReadOnly = 0x00000001,
+        Undeletable = 0x00000002,
+        SkipInEnumeration = 0x00000004,
+        PropertyGetter = 0x00000008,
+        PropertySetter = 0x00000010,
+        QObjectMember = 0x00000020,
+        KeepExistingFlags = 0x00000800,
+        UserRange = 0xff000000
+    };
+    typedef QFlags<PropertyFlag> PropertyFlags;
+    enum SpecialValue {
+        NullValue,
+        UndefinedValue
+    };
+public:
+    QScriptValue();
+    ~QScriptValue();
+    QScriptValue(const QScriptValue &other);
+    QScriptValue(QScriptEngine *engine, SpecialValue val);
+    QScriptValue(QScriptEngine *engine, bool val);
+    QScriptValue(QScriptEngine *engine, int val);
+    QScriptValue(QScriptEngine *engine, uint val);
+    QScriptValue(QScriptEngine *engine, qsreal val);
+    QScriptValue(QScriptEngine *engine, const QString &val);
+    QScriptValue(QScriptEngine *engine, const char *val);
+    QScriptValue(SpecialValue value);
+    QScriptValue(bool value);
+    QScriptValue(int value);
+    QScriptValue(uint value);
+    QScriptValue(qsreal value);
+    QScriptValue(const QString &value);
+    QScriptValue(const QLatin1String &value);
+    QScriptValue(const char *value);
+    QScriptValue &operator=(const QScriptValue &other);
+    QScriptEngine *engine() const;
+    bool isValid() const;
+    bool isBool() const;
+    bool isBoolean() const;
+    bool isNumber() const;
+    bool isFunction() const;
+    bool isNull() const;
+    bool isString() const;
+    bool isUndefined() const;
+    bool isVariant() const;
+    bool isQObject() const;
+    bool isQMetaObject() const;
+    bool isObject() const;
+    bool isDate() const;
+    bool isRegExp() const;
+    bool isArray() const;
+    bool isError() const;
+    QString toString() const;
+    qsreal toNumber() const;
+    bool toBool() const;
+    bool toBoolean() const;
+    qsreal toInteger() const;
+    qint32 toInt32() const;
+    quint32 toUInt32() const;
+    quint16 toUInt16() const;
+    QVariant toVariant() const;
+    QObject *toQObject() const;
+    const QMetaObject *toQMetaObject() const;
+    QScriptValue toObject() const;
+    QDateTime toDateTime() const;
+    QRegExp toRegExp() const;
+    bool instanceOf(const QScriptValue &other) const;
+    bool lessThan(const QScriptValue &other) const;
+    bool equals(const QScriptValue &other) const;
+    bool strictlyEquals(const QScriptValue &other) const;
+    QScriptValue prototype() const;
+    void setPrototype(const QScriptValue &prototype);
+    QScriptValue scope() const;
+    void setScope(const QScriptValue &scope);
+    QScriptValue property(const QString &name,
+                          const ResolveFlags &mode = ResolvePrototype) const;
+    void setProperty(const QString &name, const QScriptValue &value,
+                     const PropertyFlags &flags = KeepExistingFlags);
+    QScriptValue property(quint32 arrayIndex,
+                          const ResolveFlags &mode = ResolvePrototype) const;
+    void setProperty(quint32 arrayIndex, const QScriptValue &value,
+                     const PropertyFlags &flags = KeepExistingFlags);
+    QScriptValue property(const QScriptString &name,
+                          const ResolveFlags &mode = ResolvePrototype) const;
+    void setProperty(const QScriptString &name, const QScriptValue &value,
+                     const PropertyFlags &flags = KeepExistingFlags);
+    QScriptValue::PropertyFlags propertyFlags(
+        const QString &name, const ResolveFlags &mode = ResolvePrototype) const;
+    QScriptValue::PropertyFlags propertyFlags(
+        const QScriptString &name, const ResolveFlags &mode = ResolvePrototype) const;
+    QScriptValue call(const QScriptValue &thisObject = QScriptValue(),
+                      const QScriptValueList &args = QScriptValueList());
+    QScriptValue call(const QScriptValue &thisObject,
+                      const QScriptValue &arguments);
+    QScriptValue construct(const QScriptValueList &args = QScriptValueList());
+    QScriptValue construct(const QScriptValue &arguments);
+    QScriptValue data() const;
+    void setData(const QScriptValue &data);
+    QScriptClass *scriptClass() const;
+    void setScriptClass(QScriptClass *scriptClass);
+    qint64 objectId() const;
+private:
+    QScriptValue(void *);
+    QScriptValue(QScriptEngine *, void *);
+    QScriptValue(QScriptValuePrivate*);
+private:
+    QExplicitlySharedDataPointer<QScriptValuePrivate> d_ptr;
+    inline QScriptValuePrivate* d_func() { return reinterpret_cast<QScriptValuePrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptValuePrivate* d_func() const { return reinterpret_cast<const QScriptValuePrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptValuePrivate;
+    friend class QScriptEnginePrivate;
+};
+ inline QFlags<QScriptValue::ResolveFlags::enum_type> operator|(QScriptValue::ResolveFlags::enum_type f1, QScriptValue::ResolveFlags::enum_type f2) { return QFlags<QScriptValue::ResolveFlags::enum_type>(f1) | f2; } inline QFlags<QScriptValue::ResolveFlags::enum_type> operator|(QScriptValue::ResolveFlags::enum_type f1, QFlags<QScriptValue::ResolveFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QScriptValue::ResolveFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+ inline QFlags<QScriptValue::PropertyFlags::enum_type> operator|(QScriptValue::PropertyFlags::enum_type f1, QScriptValue::PropertyFlags::enum_type f2) { return QFlags<QScriptValue::PropertyFlags::enum_type>(f1) | f2; } inline QFlags<QScriptValue::PropertyFlags::enum_type> operator|(QScriptValue::PropertyFlags::enum_type f1, QFlags<QScriptValue::PropertyFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QScriptValue::PropertyFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptString;
+class QScriptClassPropertyIterator;
+class QScriptClassPrivate;
+class QScriptClass
+{
+public:
+    enum QueryFlag {
+        HandlesReadAccess = 0x01,
+        HandlesWriteAccess = 0x02
+    };
+    typedef QFlags<QueryFlag> QueryFlags;
+    enum Extension {
+        Callable,
+        HasInstance
+    };
+    QScriptClass(QScriptEngine *engine);
+    virtual ~QScriptClass();
+    QScriptEngine *engine() const;
+    virtual QueryFlags queryProperty(const QScriptValue &object,
+                                     const QScriptString &name,
+                                     QueryFlags flags, uint *id);
+    virtual QScriptValue property(const QScriptValue &object,
+                                  const QScriptString &name, uint id);
+    virtual void setProperty(QScriptValue &object, const QScriptString &name,
+                             uint id, const QScriptValue &value);
+    virtual QScriptValue::PropertyFlags propertyFlags(
+        const QScriptValue &object, const QScriptString &name, uint id);
+    virtual QScriptClassPropertyIterator *newIterator(const QScriptValue &object);
+    virtual QScriptValue prototype() const;
+    virtual QString name() const;
+    virtual bool supportsExtension(Extension extension) const;
+    virtual QVariant extension(Extension extension,
+                               const QVariant &argument = QVariant());
+protected:
+    QScriptClass(QScriptEngine *engine, QScriptClassPrivate &dd);
+    QScopedPointer<QScriptClassPrivate> d_ptr;
+private:
+    inline QScriptClassPrivate* d_func() { return reinterpret_cast<QScriptClassPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptClassPrivate* d_func() const { return reinterpret_cast<const QScriptClassPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptClassPrivate;
+    QScriptClass(const QScriptClass &); QScriptClass &operator=(const QScriptClass &);
+};
+ inline QFlags<QScriptClass::QueryFlags::enum_type> operator|(QScriptClass::QueryFlags::enum_type f1, QScriptClass::QueryFlags::enum_type f2) { return QFlags<QScriptClass::QueryFlags::enum_type>(f1) | f2; } inline QFlags<QScriptClass::QueryFlags::enum_type> operator|(QScriptClass::QueryFlags::enum_type f1, QFlags<QScriptClass::QueryFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QScriptClass::QueryFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptClassPropertyIteratorPrivate;
+class QScriptClassPropertyIterator
+{
+protected:
+    QScriptClassPropertyIterator(const QScriptValue &object);
+public:
+    virtual ~QScriptClassPropertyIterator();
+    QScriptValue object() const;
+    virtual bool hasNext() const = 0;
+    virtual void next() = 0;
+    virtual bool hasPrevious() const = 0;
+    virtual void previous() = 0;
+    virtual void toFront() = 0;
+    virtual void toBack() = 0;
+    virtual QScriptString name() const = 0;
+    virtual uint id() const;
+    virtual QScriptValue::PropertyFlags flags() const;
+protected:
+    QScriptClassPropertyIterator(const QScriptValue &object, QScriptClassPropertyIteratorPrivate &dd);
+    QScopedPointer<QScriptClassPropertyIteratorPrivate> d_ptr;
+private:
+    inline QScriptClassPropertyIteratorPrivate* d_func() { return reinterpret_cast<QScriptClassPropertyIteratorPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptClassPropertyIteratorPrivate* d_func() const { return reinterpret_cast<const QScriptClassPropertyIteratorPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptClassPropertyIteratorPrivate;
+    QScriptClassPropertyIterator(const QScriptClassPropertyIterator &); QScriptClassPropertyIterator &operator=(const QScriptClassPropertyIterator &);
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptContextPrivate;
+class QScriptContext
+{
+public:
+    enum ExecutionState {
+        NormalState,
+        ExceptionState
+    };
+    enum Error {
+        UnknownError,
+        ReferenceError,
+        SyntaxError,
+        TypeError,
+        RangeError,
+        URIError
+    };
+    ~QScriptContext();
+    QScriptContext *parentContext() const;
+    QScriptEngine *engine() const;
+    ExecutionState state() const;
+    QScriptValue callee() const;
+    int argumentCount() const;
+    QScriptValue argument(int index) const;
+    QScriptValue argumentsObject() const;
+    QScriptValueList scopeChain() const;
+    void pushScope(const QScriptValue &object);
+    QScriptValue popScope();
+    QScriptValue returnValue() const;
+    void setReturnValue(const QScriptValue &result);
+    QScriptValue activationObject() const;
+    void setActivationObject(const QScriptValue &activation);
+    QScriptValue thisObject() const;
+    void setThisObject(const QScriptValue &thisObject);
+    bool isCalledAsConstructor() const;
+    QScriptValue throwValue(const QScriptValue &value);
+    QScriptValue throwError(Error error, const QString &text);
+    QScriptValue throwError(const QString &text);
+    QStringList backtrace() const;
+    QString toString() const;
+private:
+    QScriptContext();
+    QScriptContextPrivate *d_ptr;
+    inline QScriptContextPrivate* d_func() { return reinterpret_cast<QScriptContextPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptContextPrivate* d_func() const { return reinterpret_cast<const QScriptContextPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptContextPrivate;
+    QScriptContext(const QScriptContext &); QScriptContext &operator=(const QScriptContext &);
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptContext;
+class QDataStream;
+class QScriptContextInfoPrivate;
+class QScriptContextInfo
+{
+public:
+    friend QDataStream &operator<<(QDataStream &, const QScriptContextInfo &);
+    friend QDataStream &operator>>(QDataStream &, QScriptContextInfo &);
+    enum FunctionType {
+        ScriptFunction,
+        QtFunction,
+        QtPropertyFunction,
+        NativeFunction
+    };
+    QScriptContextInfo(const QScriptContext *context);
+    QScriptContextInfo(const QScriptContextInfo &other);
+    QScriptContextInfo();
+    ~QScriptContextInfo();
+    QScriptContextInfo &operator=(const QScriptContextInfo &other);
+    bool isNull() const;
+    qint64 scriptId() const;
+    QString fileName() const;
+    int lineNumber() const;
+    int columnNumber() const;
+    QString functionName() const;
+    FunctionType functionType() const;
+    QStringList functionParameterNames() const;
+    int functionStartLineNumber() const;
+    int functionEndLineNumber() const;
+    int functionMetaIndex() const;
+    bool operator==(const QScriptContextInfo &other) const;
+    bool operator!=(const QScriptContextInfo &other) const;
+private:
+    QExplicitlySharedDataPointer<QScriptContextInfoPrivate> d_ptr;
+    inline QScriptContextInfoPrivate* d_func() { return reinterpret_cast<QScriptContextInfoPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptContextInfoPrivate* d_func() const { return reinterpret_cast<const QScriptContextInfoPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptContextInfoPrivate;
+};
+typedef QList<QScriptContextInfo> QScriptContextInfoList;
+ QDataStream &operator<<(QDataStream &, const QScriptContextInfo &);
+ QDataStream &operator>>(QDataStream &, QScriptContextInfo &);
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptStringPrivate;
+class QScriptString
+{
+public:
+    QScriptString();
+    QScriptString(const QScriptString &other);
+    ~QScriptString();
+    QScriptString &operator=(const QScriptString &other);
+    bool isValid() const;
+    bool operator==(const QScriptString &other) const;
+    bool operator!=(const QScriptString &other) const;
+    quint32 toArrayIndex(bool *ok = 0) const;
+    QString toString() const;
+    operator QString() const;
+private:
+    QExplicitlySharedDataPointer<QScriptStringPrivate> d_ptr;
+    friend class QScriptValue;
+    inline QScriptStringPrivate* d_func() { return reinterpret_cast<QScriptStringPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptStringPrivate* d_func() const { return reinterpret_cast<const QScriptStringPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptStringPrivate;
+};
+ uint qHash(const QScriptString &key);
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptProgramPrivate;
+class QScriptProgram
+{
+public:
+    QScriptProgram();
+    QScriptProgram(const QString &sourceCode,
+                   const QString fileName = QString(),
+                   int firstLineNumber = 1);
+    QScriptProgram(const QScriptProgram &other);
+    ~QScriptProgram();
+    QScriptProgram &operator=(const QScriptProgram &other);
+    bool isNull() const;
+    QString sourceCode() const;
+    QString fileName() const;
+    int firstLineNumber() const;
+    bool operator==(const QScriptProgram &other) const;
+    bool operator!=(const QScriptProgram &other) const;
+private:
+    QExplicitlySharedDataPointer<QScriptProgramPrivate> d_ptr;
+    inline QScriptProgramPrivate* d_func() { return reinterpret_cast<QScriptProgramPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptProgramPrivate* d_func() const { return reinterpret_cast<const QScriptProgramPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptProgramPrivate;
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QDateTime;
+class QScriptClass;
+class QScriptEngineAgent;
+class QScriptEnginePrivate;
+template <class T>
+inline QScriptValue qscriptQMetaObjectConstructor(QScriptContext *, QScriptEngine *, T *)
+{
+    return QScriptValue();
+}
+class QRegExp;
+template <typename T>
+inline QScriptValue qScriptValueFromValue(QScriptEngine *, const T &);
+template <typename T>
+inline T qscriptvalue_cast(const QScriptValue &);
+class QScriptSyntaxCheckResultPrivate;
+class QScriptSyntaxCheckResult
+{
+public:
+    enum State {
+        Error,
+        Intermediate,
+        Valid
+    };
+    QScriptSyntaxCheckResult(const QScriptSyntaxCheckResult &other);
+    ~QScriptSyntaxCheckResult();
+    State state() const;
+    int errorLineNumber() const;
+    int errorColumnNumber() const;
+    QString errorMessage() const;
+    QScriptSyntaxCheckResult &operator=(const QScriptSyntaxCheckResult &other);
+private:
+    QScriptSyntaxCheckResult();
+    QScriptSyntaxCheckResult(QScriptSyntaxCheckResultPrivate *d);
+    QExplicitlySharedDataPointer<QScriptSyntaxCheckResultPrivate> d_ptr;
+    inline QScriptSyntaxCheckResultPrivate* d_func() { return reinterpret_cast<QScriptSyntaxCheckResultPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptSyntaxCheckResultPrivate* d_func() const { return reinterpret_cast<const QScriptSyntaxCheckResultPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptSyntaxCheckResultPrivate;
+    friend class QScriptEngine;
+    friend class QScriptEnginePrivate;
+};
+class QScriptEngine
+    : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum ValueOwnership {
+        QtOwnership,
+        ScriptOwnership,
+        AutoOwnership
+    };
+    enum QObjectWrapOption {
+        ExcludeChildObjects = 0x0001,
+        ExcludeSuperClassMethods = 0x0002,
+        ExcludeSuperClassProperties = 0x0004,
+        ExcludeSuperClassContents = 0x0006,
+        SkipMethodsInEnumeration = 0x0008,
+        ExcludeDeleteLater = 0x0010,
+        ExcludeSlots = 0x0020,
+        AutoCreateDynamicProperties = 0x0100,
+        PreferExistingWrapperObject = 0x0200
+    };
+    typedef QFlags<QObjectWrapOption> QObjectWrapOptions;
+    QScriptEngine();
+    explicit QScriptEngine(QObject *parent);
+    virtual ~QScriptEngine();
+    QScriptValue globalObject() const;
+    void setGlobalObject(const QScriptValue &object);
+    QScriptContext *currentContext() const;
+    QScriptContext *pushContext();
+    void popContext();
+    bool canEvaluate(const QString &program) const;
+    static QScriptSyntaxCheckResult checkSyntax(const QString &program);
+    QScriptValue evaluate(const QString &program, const QString &fileName = QString(), int lineNumber = 1);
+    QScriptValue evaluate(const QScriptProgram &program);
+    bool isEvaluating() const;
+    void abortEvaluation(const QScriptValue &result = QScriptValue());
+    bool hasUncaughtException() const;
+    QScriptValue uncaughtException() const;
+    int uncaughtExceptionLineNumber() const;
+    QStringList uncaughtExceptionBacktrace() const;
+    void clearExceptions();
+    QScriptValue nullValue();
+    QScriptValue undefinedValue();
+    typedef QScriptValue (*FunctionSignature)(QScriptContext *, QScriptEngine *);
+    typedef QScriptValue (*FunctionWithArgSignature)(QScriptContext *, QScriptEngine *, void *);
+    QScriptValue newFunction(FunctionSignature signature, int length = 0);
+    QScriptValue newFunction(FunctionSignature signature, const QScriptValue &prototype, int length = 0);
+    QScriptValue newFunction(FunctionWithArgSignature signature, void *arg);
+    QScriptValue newVariant(const QVariant &value);
+    QScriptValue newVariant(const QScriptValue &object, const QVariant &value);
+    QScriptValue newRegExp(const QRegExp &regexp);
+    QScriptValue newObject();
+    QScriptValue newObject(QScriptClass *scriptClass, const QScriptValue &data = QScriptValue());
+    QScriptValue newArray(uint length = 0);
+    QScriptValue newRegExp(const QString &pattern, const QString &flags);
+    QScriptValue newDate(qsreal value);
+    QScriptValue newDate(const QDateTime &value);
+    QScriptValue newActivationObject();
+    QScriptValue newQObject(QObject *object, ValueOwnership ownership = QtOwnership,
+                            const QObjectWrapOptions &options = 0);
+    QScriptValue newQObject(const QScriptValue &scriptObject, QObject *qtObject,
+                            ValueOwnership ownership = QtOwnership,
+                            const QObjectWrapOptions &options = 0);
+    QScriptValue newQMetaObject(const QMetaObject *metaObject, const QScriptValue &ctor = QScriptValue());
+    template <class T> QScriptValue scriptValueFromQMetaObject();
+    QScriptValue defaultPrototype(int metaTypeId) const;
+    void setDefaultPrototype(int metaTypeId, const QScriptValue &prototype);
+    typedef QScriptValue (*MarshalFunction)(QScriptEngine *, const void *);
+    typedef void (*DemarshalFunction)(const QScriptValue &, void *);
+    template <typename T>
+    inline QScriptValue toScriptValue(const T &value)
+    {
+        return qScriptValueFromValue(this, value);
+    }
+    template <typename T>
+    inline T fromScriptValue(const QScriptValue &value)
+    {
+        return qscriptvalue_cast<T>(value);
+    }
+    void installTranslatorFunctions(const QScriptValue &object = QScriptValue());
+    QScriptValue importExtension(const QString &extension);
+    QStringList availableExtensions() const;
+    QStringList importedExtensions() const;
+    void collectGarbage();
+    void reportAdditionalMemoryCost(int size);
+    void setProcessEventsInterval(int interval);
+    int processEventsInterval() const;
+    void setAgent(QScriptEngineAgent *agent);
+    QScriptEngineAgent *agent() const;
+    QScriptString toStringHandle(const QString &str);
+    QScriptValue toObject(const QScriptValue &value);
+    QScriptValue objectById(qint64 id) const;
+protected:
+    void signalHandlerException(const QScriptValue &exception);
+private:
+    QScriptValue create(int type, const void *ptr);
+    bool convert(const QScriptValue &value, int type, void *ptr);
+    static bool convertV2(const QScriptValue &value, int type, void *ptr);
+    void registerCustomType(int type, MarshalFunction mf, DemarshalFunction df,
+                            const QScriptValue &prototype);
+    friend inline void qScriptRegisterMetaType_helper(QScriptEngine *,
+        int, MarshalFunction, DemarshalFunction, const QScriptValue &);
+    friend inline QScriptValue qScriptValueFromValue_helper(QScriptEngine *, int, const void *);
+    friend inline bool qscriptvalue_cast_helper(const QScriptValue &, int, void *);
+protected:
+    QScriptEngine(QScriptEnginePrivate &dd, QObject *parent = 0);
+private:
+    inline QScriptEnginePrivate* d_func() { return reinterpret_cast<QScriptEnginePrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptEnginePrivate* d_func() const { return reinterpret_cast<const QScriptEnginePrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptEnginePrivate;
+    QScriptEngine(const QScriptEngine &); QScriptEngine &operator=(const QScriptEngine &);
+};
+template <class T> QScriptValue QScriptEngine::scriptValueFromQMetaObject()
+{
+    typedef QScriptValue(*ConstructPtr)(QScriptContext *, QScriptEngine *, T *);
+    ConstructPtr cptr = qscriptQMetaObjectConstructor<T>;
+    return newQMetaObject(&T::staticMetaObject,
+                            newFunction(reinterpret_cast<FunctionWithArgSignature>(cptr), 0));
+}
+template <class T>
+inline QScriptValue qScriptValueFromQMetaObject(
+    QScriptEngine *engine
+    , T * = 0
+    )
+{
+    return engine->scriptValueFromQMetaObject<T>();
+}
+inline QScriptValue qScriptValueFromValue_helper(QScriptEngine *engine, int type, const void *ptr)
+{
+    if (!engine)
+        return QScriptValue();
+    return engine->create(type, ptr);
+}
+template <typename T>
+inline QScriptValue qScriptValueFromValue(QScriptEngine *engine, const T &t)
+{
+    return qScriptValueFromValue_helper(engine, qMetaTypeId<T>(), &t);
+}
+template <>
+inline QScriptValue qScriptValueFromValue<QVariant>(QScriptEngine *engine, const QVariant &v)
+{
+    return qScriptValueFromValue_helper(engine, v.userType(), v.data());
+}
+inline bool qscriptvalue_cast_helper(const QScriptValue &value, int type, void *ptr)
+{
+    return QScriptEngine::convertV2(value, type, ptr);
+}
+template<typename T>
+T qscriptvalue_cast(const QScriptValue &value)
+{
+    T t;
+    const int id = qMetaTypeId<T>();
+    if (qscriptvalue_cast_helper(value, id, &t))
+        return t;
+    else if (value.isVariant())
+        return qvariant_cast<T>(value.toVariant());
+    return T();
+}
+template <>
+inline QVariant qscriptvalue_cast<QVariant>(const QScriptValue &value)
+{
+    return value.toVariant();
+}
+template <typename T>
+inline T qScriptValueToValue(const QScriptValue &value)
+{
+    return qscriptvalue_cast<T>(value);
+}
+inline void qScriptRegisterMetaType_helper(QScriptEngine *eng, int type,
+                                           QScriptEngine::MarshalFunction mf,
+                                           QScriptEngine::DemarshalFunction df,
+                                           const QScriptValue &prototype)
+{
+    eng->registerCustomType(type, mf, df, prototype);
+}
+template<typename T>
+int qScriptRegisterMetaType(
+    QScriptEngine *eng,
+    QScriptValue (*toScriptValue)(QScriptEngine *, const T &t),
+    void (*fromScriptValue)(const QScriptValue &, T &t),
+    const QScriptValue &prototype = QScriptValue()
+    , T * = 0
+)
+{
+    const int id = qRegisterMetaType<T>();
+    qScriptRegisterMetaType_helper(
+        eng, id, reinterpret_cast<QScriptEngine::MarshalFunction>(toScriptValue),
+        reinterpret_cast<QScriptEngine::DemarshalFunction>(fromScriptValue),
+        prototype);
+    return id;
+}
+template <class Container>
+QScriptValue qScriptValueFromSequence(QScriptEngine *eng, const Container &cont)
+{
+    QScriptValue a = eng->newArray();
+    typename Container::const_iterator begin = cont.begin();
+    typename Container::const_iterator end = cont.end();
+    typename Container::const_iterator it;
+    quint32 i;
+    for (it = begin, i = 0; it != end; ++it, ++i)
+        a.setProperty(i, eng->toScriptValue(*it));
+    return a;
+}
+template <class Container>
+void qScriptValueToSequence(const QScriptValue &value, Container &cont)
+{
+    quint32 len = value.property(QLatin1String("length")).toUInt32();
+    for (quint32 i = 0; i < len; ++i) {
+        QScriptValue item = value.property(i);
+        cont.push_back(qscriptvalue_cast<typename Container::value_type>(item));
+    }
+}
+template<typename T>
+int qScriptRegisterSequenceMetaType(
+    QScriptEngine *engine,
+    const QScriptValue &prototype = QScriptValue()
+    , T * = 0
+)
+{
+    return qScriptRegisterMetaType<T>(engine, qScriptValueFromSequence,
+                                      qScriptValueToSequence, prototype);
+}
+ bool qScriptConnect(QObject *sender, const char *signal,
+                                    const QScriptValue &receiver,
+                                    const QScriptValue &function);
+ bool qScriptDisconnect(QObject *sender, const char *signal,
+                                       const QScriptValue &receiver,
+                                       const QScriptValue &function);
+ inline QFlags<QScriptEngine::QObjectWrapOptions::enum_type> operator|(QScriptEngine::QObjectWrapOptions::enum_type f1, QScriptEngine::QObjectWrapOptions::enum_type f2) { return QFlags<QScriptEngine::QObjectWrapOptions::enum_type>(f1) | f2; } inline QFlags<QScriptEngine::QObjectWrapOptions::enum_type> operator|(QScriptEngine::QObjectWrapOptions::enum_type f1, QFlags<QScriptEngine::QObjectWrapOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QScriptEngine::QObjectWrapOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptEngine;
+class QScriptValue;
+class QScriptEngineAgentPrivate;
+class QScriptEngineAgent
+{
+public:
+    enum Extension {
+        DebuggerInvocationRequest
+    };
+    QScriptEngineAgent(QScriptEngine *engine);
+    virtual ~QScriptEngineAgent();
+    virtual void scriptLoad(qint64 id, const QString &program,
+                            const QString &fileName, int baseLineNumber);
+    virtual void scriptUnload(qint64 id);
+    virtual void contextPush();
+    virtual void contextPop();
+    virtual void functionEntry(qint64 scriptId);
+    virtual void functionExit(qint64 scriptId,
+                              const QScriptValue &returnValue);
+    virtual void positionChange(qint64 scriptId,
+                                int lineNumber, int columnNumber);
+    virtual void exceptionThrow(qint64 scriptId,
+                                const QScriptValue &exception,
+                                bool hasHandler);
+    virtual void exceptionCatch(qint64 scriptId,
+                                const QScriptValue &exception);
+    virtual bool supportsExtension(Extension extension) const;
+    virtual QVariant extension(Extension extension,
+                               const QVariant &argument = QVariant());
+    QScriptEngine *engine() const;
+protected:
+    QScriptEngineAgent(QScriptEngineAgentPrivate &dd, QScriptEngine *engine);
+    QScopedPointer<QScriptEngineAgentPrivate> d_ptr;
+private:
+    inline QScriptEngineAgentPrivate* d_func() { return reinterpret_cast<QScriptEngineAgentPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptEngineAgentPrivate* d_func() const { return reinterpret_cast<const QScriptEngineAgentPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptEngineAgentPrivate;
+    QScriptEngineAgent(const QScriptEngineAgent &); QScriptEngineAgent &operator=(const QScriptEngineAgent &);
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptEngine;
+struct QScriptExtensionInterface
+    : public QFactoryInterface
+{
+    virtual void initialize(const QString &key, QScriptEngine *engine) = 0;
+};
+template <> inline const char *qobject_interface_iid<QScriptExtensionInterface *>() { return "com.trolltech.Qt.QScriptExtensionInterface/1.0"; } template <> inline QScriptExtensionInterface *qobject_cast<QScriptExtensionInterface *>(QObject *object) { return reinterpret_cast<QScriptExtensionInterface *>((object ? object->qt_metacast("com.trolltech.Qt.QScriptExtensionInterface/1.0") : 0)); } template <> inline QScriptExtensionInterface *qobject_cast<QScriptExtensionInterface *>(const QObject *object) { return reinterpret_cast<QScriptExtensionInterface *>((object ? const_cast<QObject *>(object)->qt_metacast("com.trolltech.Qt.QScriptExtensionInterface/1.0") : 0)); }
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QScriptValue;
+class QScriptExtensionPlugin : public QObject,
+                                               public QScriptExtensionInterface
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    explicit QScriptExtensionPlugin(QObject *parent = 0);
+    ~QScriptExtensionPlugin();
+    virtual QStringList keys() const = 0;
+    virtual void initialize(const QString &key, QScriptEngine *engine) = 0;
+    QScriptValue setupPackage(const QString &key, QScriptEngine *engine) const;
+};
+typedef QtValidLicenseForScriptModule QtScriptModule;
+class QString;
+class QScriptString;
+class QScriptValueIteratorPrivate;
+class QScriptValueIterator
+{
+public:
+    QScriptValueIterator(const QScriptValue &value);
+    ~QScriptValueIterator();
+    bool hasNext() const;
+    void next();
+    bool hasPrevious() const;
+    void previous();
+    QString name() const;
+    QScriptString scriptName() const;
+    QScriptValue value() const;
+    void setValue(const QScriptValue &value);
+    QScriptValue::PropertyFlags flags() const;
+    void remove();
+    void toFront();
+    void toBack();
+    QScriptValueIterator& operator=(QScriptValue &value);
+private:
+    QScopedPointer<QScriptValueIteratorPrivate> d_ptr;
+    inline QScriptValueIteratorPrivate* d_func() { return reinterpret_cast<QScriptValueIteratorPrivate *>(qGetPtrHelper(d_ptr)); } inline const QScriptValueIteratorPrivate* d_func() const { return reinterpret_cast<const QScriptValueIteratorPrivate *>(qGetPtrHelper(d_ptr)); } friend class QScriptValueIteratorPrivate;
+    QScriptValueIterator(const QScriptValueIterator &); QScriptValueIterator &operator=(const QScriptValueIterator &);
+};
+typedef QtValidLicenseForGuiModule QtGuiModule;
+typedef unsigned int QRgb;
+const QRgb RGB_MASK = 0x00ffffff;
+ inline int qRed(QRgb rgb)
+{ return ((rgb >> 16) & 0xff); }
+ inline int qGreen(QRgb rgb)
+{ return ((rgb >> 8) & 0xff); }
+ inline int qBlue(QRgb rgb)
+{ return (rgb & 0xff); }
+ inline int qAlpha(QRgb rgb)
+{ return rgb >> 24; }
+ inline QRgb qRgb(int r, int g, int b)
+{ return (0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+ inline QRgb qRgba(int r, int g, int b, int a)
+{ return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+ inline int qGray(int r, int g, int b)
+{ return (r*11+g*16+b*5)/32; }
+ inline int qGray(QRgb rgb)
+{ return qGray(qRed(rgb), qGreen(rgb), qBlue(rgb)); }
+ inline bool qIsGray(QRgb rgb)
+{ return qRed(rgb) == qGreen(rgb) && qRed(rgb) == qBlue(rgb); }
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QColor;
+class QColormap;
+class QVariant;
+ QDebug operator<<(QDebug, const QColor &);
+ QDataStream &operator<<(QDataStream &, const QColor &);
+ QDataStream &operator>>(QDataStream &, QColor &);
+class QColor
+{
+public:
+    enum Spec { Invalid, Rgb, Hsv, Cmyk, Hsl };
+    QColor();
+    QColor(Qt::GlobalColor color);
+    QColor(int r, int g, int b, int a = 255);
+    QColor(QRgb rgb);
+    QColor(const QString& name);
+    QColor(const char *name);
+    QColor(const QColor &color);
+    QColor(Spec spec);
+    bool isValid() const;
+    QString name() const;
+    void setNamedColor(const QString& name);
+    static QStringList colorNames();
+    inline Spec spec() const
+    { return cspec; }
+    int alpha() const;
+    void setAlpha(int alpha);
+    qreal alphaF() const;
+    void setAlphaF(qreal alpha);
+    int red() const;
+    int green() const;
+    int blue() const;
+    void setRed(int red);
+    void setGreen(int green);
+    void setBlue(int blue);
+    qreal redF() const;
+    qreal greenF() const;
+    qreal blueF() const;
+    void setRedF(qreal red);
+    void setGreenF(qreal green);
+    void setBlueF(qreal blue);
+    void getRgb(int *r, int *g, int *b, int *a = 0) const;
+    void setRgb(int r, int g, int b, int a = 255);
+    void getRgbF(qreal *r, qreal *g, qreal *b, qreal *a = 0) const;
+    void setRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+    QRgb rgba() const;
+    void setRgba(QRgb rgba);
+    QRgb rgb() const;
+    void setRgb(QRgb rgb);
+    int hue() const;
+    int saturation() const;
+    int hsvHue() const;
+    int hsvSaturation() const;
+    int value() const;
+    qreal hueF() const;
+    qreal saturationF() const;
+    qreal hsvHueF() const;
+    qreal hsvSaturationF() const;
+    qreal valueF() const;
+    void getHsv(int *h, int *s, int *v, int *a = 0) const;
+    void setHsv(int h, int s, int v, int a = 255);
+    void getHsvF(qreal *h, qreal *s, qreal *v, qreal *a = 0) const;
+    void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+    int cyan() const;
+    int magenta() const;
+    int yellow() const;
+    int black() const;
+    qreal cyanF() const;
+    qreal magentaF() const;
+    qreal yellowF() const;
+    qreal blackF() const;
+    void getCmyk(int *c, int *m, int *y, int *k, int *a = 0);
+    void setCmyk(int c, int m, int y, int k, int a = 255);
+    void getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a = 0);
+    void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+    int hslHue() const;
+    int hslSaturation() const;
+    int lightness() const;
+    qreal hslHueF() const;
+    qreal hslSaturationF() const;
+    qreal lightnessF() const;
+    void getHsl(int *h, int *s, int *l, int *a = 0) const;
+    void setHsl(int h, int s, int l, int a = 255);
+    void getHslF(qreal *h, qreal *s, qreal *l, qreal *a = 0) const;
+    void setHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+    QColor toRgb() const;
+    QColor toHsv() const;
+    QColor toCmyk() const;
+    QColor toHsl() const;
+    QColor convertTo(Spec colorSpec) const;
+    static QColor fromRgb(QRgb rgb);
+    static QColor fromRgba(QRgb rgba);
+    static QColor fromRgb(int r, int g, int b, int a = 255);
+    static QColor fromRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+    static QColor fromHsv(int h, int s, int v, int a = 255);
+    static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+    static QColor fromCmyk(int c, int m, int y, int k, int a = 255);
+    static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+    static QColor fromHsl(int h, int s, int l, int a = 255);
+    static QColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+    QColor light(int f = 150) const;
+    QColor lighter(int f = 150) const;
+    QColor dark(int f = 200) const;
+    QColor darker(int f = 200) const;
+    QColor &operator=(const QColor &);
+    QColor &operator=(Qt::GlobalColor color);
+    bool operator==(const QColor &c) const;
+    bool operator!=(const QColor &c) const;
+    operator QVariant() const;
+    static bool allowX11ColorNames();
+    static void setAllowX11ColorNames(bool enabled);
+    static bool isValidColor(const QString &name);
+private:
+    QColor(int, int, int, Spec);
+    void invalidate();
+    bool setColorFromString(const QString &name);
+    Spec cspec;
+    union {
+        struct {
+            ushort alpha;
+            ushort red;
+            ushort green;
+            ushort blue;
+            ushort pad;
+        } argb;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort value;
+            ushort pad;
+        } ahsv;
+        struct {
+            ushort alpha;
+            ushort cyan;
+            ushort magenta;
+            ushort yellow;
+            ushort black;
+        } acmyk;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort lightness;
+            ushort pad;
+        } ahsl;
+        ushort array[5];
+    } ct;
+    friend class QColormap;
+    friend QDataStream &operator<<(QDataStream &, const QColor &);
+    friend QDataStream &operator>>(QDataStream &, QColor &);
+};
+inline QColor::QColor()
+{ invalidate(); }
+inline QColor::QColor(int r, int g, int b, int a)
+{ setRgb(r, g, b, a); }
+inline QColor::QColor(const char *aname)
+{ setNamedColor(QLatin1String(aname)); }
+inline QColor::QColor(const QString& aname)
+{ setNamedColor(aname); }
+inline QColor::QColor(const QColor &acolor)
+    : cspec(acolor.cspec)
+{ ct.argb = acolor.ct.argb; }
+inline bool QColor::isValid() const
+{ return cspec != Invalid; }
+inline QColor QColor::lighter(int f) const
+{ return light(f); }
+inline QColor QColor::darker(int f) const
+{ return dark(f); }
+class KLocale;
+struct KCatalogName;
+class KLocalizedStringPrivate;
+class __attribute__ ((visibility("default"))) KLocalizedString
+{
+    friend KLocalizedString __attribute__ ((visibility("default"))) ki18n (const char* msg);
+    friend KLocalizedString __attribute__ ((visibility("default"))) ki18nc (const char *ctxt, const char *msg);
+    friend KLocalizedString __attribute__ ((visibility("default"))) ki18np (const char *singular, const char *plural);
+    friend KLocalizedString __attribute__ ((visibility("default"))) ki18ncp (const char *ctxt,
+                                     const char *singular, const char *plural);
+public:
+    explicit KLocalizedString ();
+    KLocalizedString (const KLocalizedString &rhs);
+    KLocalizedString& operator= (const KLocalizedString &rhs);
+    ~KLocalizedString ();
+    QString toString () const;
+    QString toString (const QString &catalogName) const;
+    QString toString (const KLocale *locale) const;
+    QString toString (const KLocale *locale, const QString &catalogName) const;
+    bool isEmpty() const;
+    KLocalizedString subs (int a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (uint a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (long a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (ulong a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (qlonglong a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (qulonglong a, int fieldWidth = 0, int base = 10,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (double a, int fieldWidth = 0,
+                           char format = 'g', int precision = -1,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (QChar a, int fieldWidth = 0,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString subs (const QString &a, int fieldWidth = 0,
+                           const QChar &fillChar = QLatin1Char(' ')) const;
+    KLocalizedString inContext (const QString &key,
+                                const QString &text) const;
+    static void notifyCatalogsUpdated (const QStringList &languages,
+                                       const QList<KCatalogName> &catalogs);
+private:
+    KLocalizedString (const char *ctxt,
+                      const char *msg, const char *plural);
+    KLocalizedStringPrivate * const d;
+};
+extern KLocalizedString __attribute__ ((visibility("default"))) ki18n (const char* msg);
+extern KLocalizedString __attribute__ ((visibility("default"))) ki18nc (const char *ctxt, const char *msg);
+extern KLocalizedString __attribute__ ((visibility("default"))) ki18np (const char *singular, const char *plural);
+extern KLocalizedString __attribute__ ((visibility("default"))) ki18ncp (const char *ctxt, const char *singular, const char *plural);
+inline QString tr2i18n (const char *message, const char *comment = 0) {
+    if (comment && comment[0] && message && message[0]) {
+        return ki18nc(comment, message).toString();
+    }
+    else if (message && message[0]) {
+        return ki18n(message).toString();
+    }
+    else {
+        return QString();
+    }
+}
+inline QString i18n (const char *text)
+{
+  return ki18n(text).toString();
+}
+template <typename A1>
+inline QString i18n (const char *text, const A1 &a1)
+{
+  return ki18n(text).subs(a1).toString();
+}
+template <typename A1, typename A2>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2)
+{
+  return ki18n(text).subs(a1).subs(a2).toString();
+}
+template <typename A1, typename A2, typename A3>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+inline QString i18n (const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+inline QString i18n (const char *text, 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)
+{
+  return ki18n(text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).subs(a9).toString();
+}
+inline QString i18nc (const char *ctxt, const char *text)
+{
+  return ki18nc(ctxt, text).toString();
+}
+template <typename A1>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1)
+{
+  return ki18nc(ctxt, text).subs(a1).toString();
+}
+template <typename A1, typename A2>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).toString();
+}
+template <typename A1, typename A2, typename A3>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+inline QString i18nc (const char *ctxt, const char *text, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+inline QString i18nc (const char *ctxt, const char *text, 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)
+{
+  return ki18nc(ctxt, text).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).subs(a9).toString();
+}
+template <typename A1>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1)
+{
+  return ki18np(sing, plur).subs(a1).toString();
+}
+template <typename A1, typename A2>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).toString();
+}
+template <typename A1, typename A2, typename A3>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+inline QString i18np (const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+inline QString i18np (const char *sing, const char *plur, 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)
+{
+  return ki18np(sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).subs(a9).toString();
+}
+template <typename A1>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).toString();
+}
+template <typename A1, typename A2>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).toString();
+}
+template <typename A1, typename A2, typename A3>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).toString();
+}
+template <typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
+inline QString i18ncp (const char *ctxt, const char *sing, const char *plur, 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)
+{
+  return ki18ncp(ctxt, sing, plur).subs(a1).subs(a2).subs(a3).subs(a4).subs(a5).subs(a6).subs(a7).subs(a8).subs(a9).toString();
+}
+namespace boost
+{
+template<class T> inline void checked_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+    void operator()(T * x) const
+    {
+        boost::checked_delete(x);
+    }
+};
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+}
+namespace boost{
+   __extension__ typedef long long long_long_type;
+   __extension__ typedef unsigned long long ulong_long_type;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <class _OutputIterator, class _Tp>
+    class raw_storage_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _OutputIterator _M_iter;
+    public:
+      explicit
+      raw_storage_iterator(_OutputIterator __x)
+      : _M_iter(__x) {}
+      raw_storage_iterator&
+      operator*() { return *this; }
+      raw_storage_iterator&
+      operator=(const _Tp& __element)
+      {
+ std::_Construct(std::__addressof(*_M_iter), __element);
+ return *this;
+      }
+      raw_storage_iterator<_OutputIterator, _Tp>&
+      operator++()
+      {
+ ++_M_iter;
+ return *this;
+      }
+      raw_storage_iterator<_OutputIterator, _Tp>
+      operator++(int)
+      {
+ raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+      }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp1>
+    struct auto_ptr_ref
+    {
+      _Tp1* _M_ptr;
+      explicit
+      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+    } ;
+  template<typename _Tp>
+    class auto_ptr
+    {
+    private:
+      _Tp* _M_ptr;
+    public:
+      typedef _Tp element_type;
+      explicit
+      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+      template<typename _Tp1>
+        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+      auto_ptr&
+      operator=(auto_ptr& __a) throw()
+      {
+ reset(__a.release());
+ return *this;
+      }
+      template<typename _Tp1>
+        auto_ptr&
+        operator=(auto_ptr<_Tp1>& __a) throw()
+        {
+   reset(__a.release());
+   return *this;
+ }
+      ~auto_ptr() { delete _M_ptr; }
+      element_type&
+      operator*() const throw()
+      {
+ ;
+ return *_M_ptr;
+      }
+      element_type*
+      operator->() const throw()
+      {
+ ;
+ return _M_ptr;
+      }
+      element_type*
+      get() const throw() { return _M_ptr; }
+      element_type*
+      release() throw()
+      {
+ element_type* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+      }
+      void
+      reset(element_type* __p = 0) throw()
+      {
+ if (__p != _M_ptr)
+   {
+     delete _M_ptr;
+     _M_ptr = __p;
+   }
+      }
+      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
+      : _M_ptr(__ref._M_ptr) { }
+      auto_ptr&
+      operator=(auto_ptr_ref<element_type> __ref) throw()
+      {
+ if (__ref._M_ptr != this->get())
+   {
+     delete _M_ptr;
+     _M_ptr = __ref._M_ptr;
+   }
+ return *this;
+      }
+      template<typename _Tp1>
+        operator auto_ptr_ref<_Tp1>() throw()
+        { return auto_ptr_ref<_Tp1>(this->release()); }
+      template<typename _Tp1>
+        operator auto_ptr<_Tp1>() throw()
+        { return auto_ptr<_Tp1>(this->release()); }
+    } ;
+  template<>
+    class auto_ptr<void>
+    {
+    public:
+      typedef void element_type;
+    } ;
+}
+namespace boost
+{
+template<class T> class scoped_ptr
+{
+private:
+    T * px;
+    scoped_ptr(scoped_ptr const &);
+    scoped_ptr & operator=(scoped_ptr const &);
+    typedef scoped_ptr<T> this_type;
+    void operator==( scoped_ptr const& ) const;
+    void operator!=( scoped_ptr const& ) const;
+public:
+    typedef T element_type;
+    explicit scoped_ptr( T * p = 0 ): px( p )
+    {
+    }
+    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() )
+    {
+    }
+    ~scoped_ptr()
+    {
+        boost::checked_delete( px );
+    }
+    void reset(T * p = 0)
+    {
+        (static_cast<void> (0));
+        this_type(p).swap(*this);
+    }
+    T & operator*() const
+    {
+        (static_cast<void> (0));
+        return *px;
+    }
+    T * operator->() const
+    {
+        (static_cast<void> (0));
+        return px;
+    }
+    T * get() const
+    {
+        return px;
+    }
+    typedef T * this_type::*unspecified_bool_type;
+    operator unspecified_bool_type() const
+    {
+        return px == 0? 0: &this_type::px;
+    }
+    bool operator! () const
+    {
+        return px == 0;
+    }
+    void swap(scoped_ptr & b)
+    {
+        T * tmp = b.px;
+        b.px = px;
+        px = tmp;
+    }
+};
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
+{
+    a.swap(b);
+}
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
+{
+    return p.get();
+}
+}
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <class T>
+        class
+        refcount_ptr
+            {
+            public:
+            refcount_ptr():
+                px_(0)
+                {
+                }
+            ~refcount_ptr()
+                {
+                release();
+                }
+            refcount_ptr( refcount_ptr const & x ):
+                px_(x.px_)
+                {
+                add_ref();
+                }
+            refcount_ptr &
+            operator=( refcount_ptr const & x )
+                {
+                adopt(x.px_);
+                return *this;
+                }
+            void
+            adopt( T * px )
+                {
+                release();
+                px_=px;
+                add_ref();
+                }
+            T *
+            get() const
+                {
+                return px_;
+                }
+            private:
+            T * px_;
+            void
+            add_ref()
+                {
+                if( px_ )
+                    px_->add_ref();
+                }
+            void
+            release()
+                {
+                if( px_ && px_->release() )
+                    px_=0;
+                }
+            };
+        }
+    template <class Tag,class T>
+    class error_info;
+    typedef error_info<struct throw_function_,char const *> throw_function;
+    typedef error_info<struct throw_file_,char const *> throw_file;
+    typedef error_info<struct throw_line_,int> throw_line;
+    template <>
+    class
+    error_info<throw_function_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+    template <>
+    class
+    error_info<throw_file_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+    template <>
+    class
+    error_info<throw_line_,int>
+        {
+        public:
+        typedef int value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+#pragma GCC visibility push (default)
+    class exception;
+#pragma GCC visibility pop
+    template <class T>
+    class shared_ptr;
+    namespace
+    exception_detail
+        {
+        class error_info_base;
+        struct type_info_;
+        struct
+        error_info_container
+            {
+            virtual char const * diagnostic_information( char const * ) const = 0;
+            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
+            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
+            virtual void add_ref() const = 0;
+            virtual bool release() const = 0;
+            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;
+            protected:
+            ~error_info_container() throw()
+                {
+                }
+            };
+        template <class>
+        struct get_info;
+        template <>
+        struct get_info<throw_function>;
+        template <>
+        struct get_info<throw_file>;
+        template <>
+        struct get_info<throw_line>;
+        char const * get_diagnostic_information( exception const &, char const * );
+        void copy_boost_exception( exception *, exception const * );
+        template <class E,class Tag,class T>
+        E const & set_info( E const &, error_info<Tag,T> const & );
+        template <class E>
+        E const & set_info( E const &, throw_function const & );
+        template <class E>
+        E const & set_info( E const &, throw_file const & );
+        template <class E>
+        E const & set_info( E const &, throw_line const & );
+        }
+#pragma GCC visibility push (default)
+    class
+    exception
+        {
+        protected:
+        exception():
+            throw_function_(0),
+            throw_file_(0),
+            throw_line_(-1)
+            {
+            }
+        virtual ~exception() throw()
+            = 0
+            ;
+        private:
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_function const & );
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_file const & );
+        template <class E>
+        friend E const & exception_detail::set_info( E const &, throw_line const & );
+        template <class E,class Tag,class T>
+        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+        template <class>
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info<throw_function>;
+        friend struct exception_detail::get_info<throw_file>;
+        friend struct exception_detail::get_info<throw_line>;
+        friend void exception_detail::copy_boost_exception( exception *, exception const * );
+        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
+        mutable char const * throw_function_;
+        mutable char const * throw_file_;
+        mutable int throw_line_;
+        };
+#pragma GCC visibility pop
+    inline
+    exception::
+    ~exception() throw()
+        {
+        }
+    namespace
+    exception_detail
+        {
+        template <class E>
+        E const &
+        set_info( E const & x, throw_function const & y )
+            {
+            x.throw_function_=y.v_;
+            return x;
+            }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_file const & y )
+            {
+            x.throw_file_=y.v_;
+            return x;
+            }
+        template <class E>
+        E const &
+        set_info( E const & x, throw_line const & y )
+            {
+            x.throw_line_=y.v_;
+            return x;
+            }
+        }
+    namespace
+    exception_detail
+        {
+        template <class T>
+        struct
+        error_info_injector:
+            public T,
+            public exception
+            {
+            explicit
+            error_info_injector( T const & x ):
+                T(x)
+                {
+                }
+            ~error_info_injector() throw()
+                {
+                }
+            };
+        struct large_size { char c[256]; };
+        large_size dispatch_boost_exception( exception const * );
+        struct small_size { };
+        small_size dispatch_boost_exception( void const * );
+        template <class,int>
+        struct enable_error_info_helper;
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(large_size)>
+            {
+            typedef T type;
+            };
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(small_size)>
+            {
+            typedef error_info_injector<T> type;
+            };
+        template <class T>
+        struct
+        enable_error_info_return_type
+            {
+            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
+            };
+        }
+    template <class T>
+    inline
+    typename
+    exception_detail::enable_error_info_return_type<T>::type
+    enable_error_info( T const & x )
+        {
+        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
+        return rt(x);
+        }
+    namespace
+    exception_detail
+        {
+        class
+        clone_base
+            {
+            public:
+            virtual clone_base const * clone() const = 0;
+            virtual void rethrow() const = 0;
+            virtual
+            ~clone_base() throw()
+                {
+                }
+            };
+        inline
+        void
+        copy_boost_exception( exception * a, exception const * b )
+            {
+            refcount_ptr<error_info_container> data;
+            if( error_info_container * d=b->data_.get() )
+                data = d->clone();
+            a->throw_file_ = b->throw_file_;
+            a->throw_line_ = b->throw_line_;
+            a->throw_function_ = b->throw_function_;
+            a->data_ = data;
+            }
+        inline
+        void
+        copy_boost_exception( void *, void const * )
+            {
+            }
+        template <class T>
+        class
+        clone_impl:
+            public T,
+            public clone_base
+            {
+            public:
+            explicit
+            clone_impl( T const & x ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+            ~clone_impl() throw()
+                {
+                }
+            private:
+            clone_base const *
+            clone() const
+                {
+                return new clone_impl(*this);
+                }
+            void
+            rethrow() const
+                {
+                throw*this;
+                }
+            };
+        }
+    template <class T>
+    inline
+    exception_detail::clone_impl<T>
+    enable_current_exception( T const & x )
+        {
+        return exception_detail::clone_impl<T>(x);
+        }
+    }
+namespace boost
+{
+namespace detail
+{
+inline void current_function_helper()
+{
+}
+}
+}
+namespace boost
+{
+inline void throw_exception_assert_compatibility( std::exception const & ) { }
+template<class E> __attribute__((noreturn)) inline void throw_exception( E const & e )
+{
+    throw_exception_assert_compatibility(e);
+    throw enable_current_exception(enable_error_info(e));
+}
+    namespace
+    exception_detail
+    {
+        template <class E>
+        __attribute__((noreturn))
+        void
+        throw_exception_( E const & x, char const * current_function, char const * file, int line )
+        {
+            boost::throw_exception(
+                set_info(
+                    set_info(
+                        set_info(
+                            boost::enable_error_info(x),
+                            throw_function(current_function)),
+                        throw_file(file)),
+                    throw_line(line)));
+        }
+    }
+}
+namespace boost
+{
+class bad_weak_ptr: public std::exception
+{
+public:
+    virtual char const * what() const throw()
+    {
+        return "tr1::bad_weak_ptr";
+    }
+};
+}
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+namespace std
+{
+  class type_info
+  {
+  public:
+    virtual ~type_info();
+    const char* name() const
+    { return __name[0] == '*' ? __name + 1 : __name; }
+    bool before(const type_info& __arg) const
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+ ? __name < __arg.__name
+ : __builtin_strcmp (__name, __arg.__name) < 0; }
+    bool operator==(const type_info& __arg) const
+    {
+      return ((__name == __arg.__name)
+       || (__name[0] != '*' &&
+    __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+    bool operator!=(const type_info& __arg) const
+    { return !operator==(__arg); }
+    virtual bool __is_pointer_p() const;
+    virtual bool __is_function_p() const;
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+       unsigned __outer) const;
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+        void **__obj_ptr) const;
+  protected:
+    const char *__name;
+    explicit type_info(const char *__n): __name(__n) { }
+  private:
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() throw() { }
+    virtual ~bad_cast() throw();
+    virtual const char* what() const throw();
+  };
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () throw() { }
+    virtual ~bad_typeid() throw();
+    virtual const char* what() const throw();
+  };
+}
+#pragma GCC visibility pop
+}
+namespace boost
+{
+namespace detail
+{
+typedef std::type_info sp_typeinfo;
+}
+}
+namespace boost
+{
+namespace detail
+{
+inline void atomic_increment( int * pw )
+{
+    int tmp;
+    __asm__
+    (
+        "0:\n\t"
+        "lwarx %1, 0, %2\n\t"
+        "addi %1, %1, 1\n\t"
+        "stwcx. %1, 0, %2\n\t"
+        "bne- 0b":
+        "=m"( *pw ), "=&b"( tmp ):
+        "r"( pw ), "m"( *pw ):
+        "cc"
+    );
+}
+inline int atomic_decrement( int * pw )
+{
+    int rv;
+    __asm__ __volatile__
+    (
+        "sync\n\t"
+        "0:\n\t"
+        "lwarx %1, 0, %2\n\t"
+        "addi %1, %1, -1\n\t"
+        "stwcx. %1, 0, %2\n\t"
+        "bne- 0b\n\t"
+        "isync":
+        "=m"( *pw ), "=&b"( rv ):
+        "r"( pw ), "m"( *pw ):
+        "memory", "cc"
+    );
+    return rv;
+}
+inline int atomic_conditional_increment( int * pw )
+{
+    int rv;
+    __asm__
+    (
+        "0:\n\t"
+        "lwarx %1, 0, %2\n\t"
+        "cmpwi %1, 0\n\t"
+        "beq 1f\n\t"
+        "addi %1, %1, 1\n\t"
+        "1:\n\t"
+        "stwcx. %1, 0, %2\n\t"
+        "bne- 0b":
+        "=m"( *pw ), "=&b"( rv ):
+        "r"( pw ), "m"( *pw ):
+        "cc"
+    );
+    return rv;
+}
+class sp_counted_base
+{
+private:
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+    int use_count_;
+    int weak_count_;
+public:
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+    virtual ~sp_counted_base()
+    {
+    }
+    virtual void dispose() = 0;
+    virtual void destroy()
+    {
+        delete this;
+    }
+    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    void add_ref_copy()
+    {
+        atomic_increment( &use_count_ );
+    }
+    bool add_ref_lock()
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+    void release()
+    {
+        if( atomic_decrement( &use_count_ ) == 0 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+    void weak_add_ref()
+    {
+        atomic_increment( &weak_count_ );
+    }
+    void weak_release()
+    {
+        if( atomic_decrement( &weak_count_ ) == 0 )
+        {
+            destroy();
+        }
+    }
+    long use_count() const
+    {
+        return static_cast<int const volatile &>( use_count_ );
+    }
+};
+}
+}
+namespace boost
+{
+namespace detail
+{
+template<class X> class sp_counted_impl_p: public sp_counted_base
+{
+private:
+    X * px_;
+    sp_counted_impl_p( sp_counted_impl_p const & );
+    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
+    typedef sp_counted_impl_p<X> this_type;
+public:
+    explicit sp_counted_impl_p( X * px ): px_( px )
+    {
+    }
+    virtual void dispose()
+    {
+        boost::checked_delete( px_ );
+    }
+    virtual void * get_deleter( detail::sp_typeinfo const & )
+    {
+        return 0;
+    }
+};
+template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
+{
+private:
+    P ptr;
+    D del;
+    sp_counted_impl_pd( sp_counted_impl_pd const & );
+    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
+    typedef sp_counted_impl_pd<P, D> this_type;
+public:
+    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( d )
+    {
+    }
+    sp_counted_impl_pd( P p ): ptr( p ), del()
+    {
+    }
+    virtual void dispose()
+    {
+        del( ptr );
+    }
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
+    }
+};
+template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
+{
+private:
+    P p_;
+    D d_;
+    A a_;
+    sp_counted_impl_pda( sp_counted_impl_pda const & );
+    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
+    typedef sp_counted_impl_pda<P, D, A> this_type;
+public:
+    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( d ), a_( a )
+    {
+    }
+    sp_counted_impl_pda( P p, A a ): p_( p ), d_(), a_( a )
+    {
+    }
+    virtual void dispose()
+    {
+        d_( p_ );
+    }
+    virtual void destroy()
+    {
+        typedef typename A::template rebind< this_type >::other A2;
+        A2 a2( a_ );
+        this->~this_type();
+        a2.deallocate( this, 1 );
+    }
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
+    }
+};
+}
+}
+namespace boost
+{
+namespace detail
+{
+struct sp_nothrow_tag {};
+template< class D > struct sp_inplace_tag
+{
+};
+class weak_count;
+class shared_count
+{
+private:
+    sp_counted_base * pi_;
+    friend class weak_count;
+public:
+    shared_count(): pi_(0)
+    {
+    }
+    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
+    {
+        try
+        {
+            pi_ = new sp_counted_impl_p<Y>( p );
+        }
+        catch(...)
+        {
+            boost::checked_delete( p );
+            throw;
+        }
+    }
+    template<class P, class D> shared_count( P p, D d ): pi_(0)
+    {
+        try
+        {
+            pi_ = new sp_counted_impl_pd<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p);
+            throw;
+        }
+    }
+    template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )
+    {
+        try
+        {
+            pi_ = new sp_counted_impl_pd< P, D >( p );
+        }
+        catch( ... )
+        {
+            D()( p );
+            throw;
+        }
+    }
+    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
+    {
+        typedef sp_counted_impl_pda<P, D, A> impl_type;
+        typedef typename A::template rebind< impl_type >::other A2;
+        A2 a2( a );
+        try
+        {
+            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+        }
+        catch(...)
+        {
+            d( p );
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+            throw;
+        }
+    }
+    template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )
+    {
+        typedef sp_counted_impl_pda< P, D, A > impl_type;
+        typedef typename A::template rebind< impl_type >::other A2;
+        A2 a2( a );
+        try
+        {
+            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, a );
+        }
+        catch(...)
+        {
+            D()( p );
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+            throw;
+        }
+    }
+    template<class Y>
+    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
+    {
+        r.release();
+    }
+    ~shared_count()
+    {
+        if( pi_ != 0 ) pi_->release();
+    }
+    shared_count(shared_count const & r): pi_(r.pi_)
+    {
+        if( pi_ != 0 ) pi_->add_ref_copy();
+    }
+    explicit shared_count(weak_count const & r);
+    shared_count( weak_count const & r, sp_nothrow_tag );
+    shared_count & operator= (shared_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        if( tmp != pi_ )
+        {
+            if( tmp != 0 ) tmp->add_ref_copy();
+            if( pi_ != 0 ) pi_->release();
+            pi_ = tmp;
+        }
+        return *this;
+    }
+    void swap(shared_count & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+    long use_count() const
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+    bool unique() const
+    {
+        return use_count() == 1;
+    }
+    bool empty() const
+    {
+        return pi_ == 0;
+    }
+    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    {
+        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
+    }
+    void * get_deleter( sp_typeinfo const & ti ) const
+    {
+        return pi_? pi_->get_deleter( ti ): 0;
+    }
+};
+class weak_count
+{
+private:
+    sp_counted_base * pi_;
+    friend class shared_count;
+public:
+    weak_count(): pi_(0)
+    {
+    }
+    weak_count(shared_count const & r): pi_(r.pi_)
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+    weak_count(weak_count const & r): pi_(r.pi_)
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+    ~weak_count()
+    {
+        if(pi_ != 0) pi_->weak_release();
+    }
+    weak_count & operator= (shared_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+        return *this;
+    }
+    weak_count & operator= (weak_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+        return *this;
+    }
+    void swap(weak_count & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+    long use_count() const
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+    bool empty() const
+    {
+        return pi_ == 0;
+    }
+    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+};
+inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
+{
+    if( pi_ == 0 || !pi_->add_ref_lock() )
+    {
+        boost::throw_exception( boost::bad_weak_ptr() );
+    }
+}
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
+{
+    if( pi_ != 0 && !pi_->add_ref_lock() )
+    {
+        pi_ = 0;
+    }
+}
+}
+}
+namespace boost
+{
+namespace detail
+{
+template< class Y, class T > struct sp_convertible
+{
+    typedef char (&yes) [1];
+    typedef char (&no) [2];
+    static yes f( T* );
+    static no f( ... );
+    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
+};
+struct sp_empty
+{
+};
+template< bool > struct sp_enable_if_convertible_impl;
+template<> struct sp_enable_if_convertible_impl<true>
+{
+    typedef sp_empty type;
+};
+template<> struct sp_enable_if_convertible_impl<false>
+{
+};
+template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
+{
+};
+}
+}
+namespace boost
+{
+namespace detail
+{
+inline void yield( unsigned k )
+{
+    if( k < 4 )
+    {
+    }
+    else if( k < 32 || k & 1 )
+    {
+        sched_yield();
+    }
+    else
+    {
+        struct timespec rqtp = { 0, 0 };
+        rqtp.tv_sec = 0;
+        rqtp.tv_nsec = 1000;
+        nanosleep( &rqtp, 0 );
+    }
+}
+}
+}
+namespace boost
+{
+namespace detail
+{
+class spinlock
+{
+public:
+    int v_;
+public:
+    bool try_lock()
+    {
+        int r = __sync_lock_test_and_set( &v_, 1 );
+        return r == 0;
+    }
+    void lock()
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+    void unlock()
+    {
+        __sync_lock_release( &v_ );
+    }
+public:
+    class scoped_lock
+    {
+    private:
+        spinlock & sp_;
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+    public:
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+}
+}
+namespace boost
+{
+namespace detail
+{
+template< int I > class spinlock_pool
+{
+private:
+    static spinlock pool_[ 41 ];
+public:
+    static spinlock & spinlock_for( void const * pv )
+    {
+        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
+        return pool_[ i ];
+    }
+    class scoped_lock
+    {
+    private:
+        spinlock & sp_;
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+    public:
+        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
+        {
+            sp_.lock();
+        }
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
+{
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}
+};
+}
+}
+namespace boost
+{
+enum memory_order
+{
+    memory_order_relaxed = 0,
+    memory_order_acquire = 1,
+    memory_order_release = 2,
+    memory_order_acq_rel = 3,
+    memory_order_seq_cst = 7,
+    memory_order_consume = 8
+};
+}
+namespace boost
+{
+template<class T> class shared_ptr;
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+template<class T> class enable_shared_from_this2;
+namespace detail
+{
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+template<class T> struct shared_ptr_traits
+{
+    typedef T & reference;
+};
+template<> struct shared_ptr_traits<void>
+{
+    typedef void reference;
+};
+template<> struct shared_ptr_traits<void const>
+{
+    typedef void reference;
+};
+template<> struct shared_ptr_traits<void volatile>
+{
+    typedef void reference;
+};
+template<> struct shared_ptr_traits<void const volatile>
+{
+    typedef void reference;
+};
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
+{
+    if( pe != 0 )
+    {
+        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
+    }
+}
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
+{
+    if( pe != 0 )
+    {
+        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
+    }
+}
+inline void sp_enable_shared_from_this( ... )
+{
+}
+template< class T, class R > struct sp_enable_if_auto_ptr
+{
+};
+template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
+{
+    typedef R type;
+};
+}
+template<class T> class shared_ptr
+{
+private:
+    typedef shared_ptr<T> this_type;
+public:
+    typedef T element_type;
+    typedef T value_type;
+    typedef T * pointer;
+    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;
+    shared_ptr(): px(0), pn()
+    {
+    }
+    template<class Y>
+    explicit shared_ptr( Y * p ): px( p ), pn( p )
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+    template<class Y>
+    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
+    {
+        px = r.px;
+    }
+    template<class Y>
+    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
+    {
+        if( !pn.empty() )
+        {
+            px = r.px;
+        }
+    }
+    template<class Y>
+    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
+    : px( r.px ), pn( r.pn )
+    {
+    }
+    template< class Y >
+    shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn )
+    {
+    }
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            pn = boost::detail::shared_count();
+        }
+    }
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            boost::throw_exception(std::bad_cast());
+        }
+    }
+    template<class Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
+    {
+        Y * tmp = r.get();
+        pn = boost::detail::shared_count(r);
+        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
+    }
+    template<class Ap>
+    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
+    {
+        typename Ap::element_type * tmp = r.get();
+        pn = boost::detail::shared_count( r );
+        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
+    }
+    shared_ptr & operator=( shared_ptr const & r )
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+    template<class Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r)
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+    template<class Y>
+    shared_ptr & operator=( std::auto_ptr<Y> & r )
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+    template<class Ap>
+    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
+    {
+        this_type( r ).swap( *this );
+        return *this;
+    }
+    void reset()
+    {
+        this_type().swap(*this);
+    }
+    template<class Y> void reset(Y * p)
+    {
+        (static_cast<void> (0));
+        this_type(p).swap(*this);
+    }
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        this_type( p, d ).swap( *this );
+    }
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        this_type( p, d, a ).swap( *this );
+    }
+    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
+    {
+        this_type( r, p ).swap( *this );
+    }
+    reference operator* () const
+    {
+        (static_cast<void> (0));
+        return *px;
+    }
+    T * operator-> () const
+    {
+        (static_cast<void> (0));
+        return px;
+    }
+    T * get() const
+    {
+        return px;
+    }
+    typedef T * this_type::*unspecified_bool_type;
+    operator unspecified_bool_type() const
+    {
+        return px == 0? 0: &this_type::px;
+    }
+    bool operator! () const
+    {
+        return px == 0;
+    }
+    bool unique() const
+    {
+        return pn.unique();
+    }
+    long use_count() const
+    {
+        return pn.use_count();
+    }
+    void swap(shared_ptr<T> & other)
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
+    {
+        return pn < rhs.pn;
+    }
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
+    {
+        return pn < rhs.pn;
+    }
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
+    {
+        return pn.get_deleter( ti );
+    }
+    bool _internal_equiv( shared_ptr const & r ) const
+    {
+        return px == r.px && pn == r.pn;
+    }
+private:
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+    T * px;
+    boost::detail::shared_count pn;
+};
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.owner_before( b );
+}
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::static_cast_tag());
+}
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::const_cast_tag());
+}
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
+}
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::static_cast_tag());
+}
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
+}
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
+}
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+{
+    (static_cast<void> (0));
+    return shared_static_cast<T>(r);
+}
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+{
+    os << p.get();
+    return os;
+}
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * )
+{
+    return false;
+}
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    return *p;
+}
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
+{
+    return atomic_load( p );
+}
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    p->swap( r );
+}
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
+{
+    atomic_store( p, r );
+}
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+    sp.lock();
+    p->swap( r );
+    sp.unlock();
+    return r;
+}
+template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
+{
+    return atomic_exchange( p, r );
+}
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+    sp.lock();
+    if( p->_internal_equiv( *v ) )
+    {
+        p->swap( w );
+        sp.unlock();
+        return true;
+    }
+    else
+    {
+        shared_ptr<T> tmp( *p );
+        sp.unlock();
+        tmp.swap( *v );
+        return false;
+    }
+}
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
+{
+    return atomic_compare_exchange( p, v, w );
+}
+template< class T > struct hash;
+template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
+{
+    return boost::hash< T* >()( p.get() );
+}
+}
+class Data;
+class Pointer;
+class DataType;
+class PointerType;
+class DataStructure;
+class Group;
+typedef QList< boost::shared_ptr<Data> > DataList;
+typedef QList< boost::shared_ptr<Pointer> > PointerList;
+typedef boost::shared_ptr<Data> DataPtr;
+typedef boost::shared_ptr<Pointer> PointerPtr;
+typedef boost::shared_ptr<DataType> DataTypePtr;
+typedef boost::shared_ptr<PointerType> PointerTypePtr;
+typedef boost::shared_ptr<DataStructure> DataStructurePtr;
+typedef boost::shared_ptr<Group> GroupPtr;
+class DocumentPrivate;
+class KUrl;
+class DataStructurePluginInterface;
+class DataStructure;
+class QtScriptBackend;
+class QSvgRenderer;
+class QPointF;
+class __attribute__ ((visibility("default"))) Document : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum Border {BorderLeft, BorderBottom, BorderRight, BorderTop};
+    explicit Document(const QString &name,
+             qreal left = -200,
+             qreal right = 200,
+             qreal top = -200,
+             qreal bottom = 200,
+             QObject *parent = 0
+            );
+    ~Document();
+    bool isModified() const;
+    void setName(const QString &name);
+    QString name() const;
+    void save();
+    void saveAs(const QString& fileUrl);
+    QString fileUrl() const;
+    void setFileUrl(const KUrl &fileUrl);
+    static bool isValidIdentifier(const QString &identifier);
+    QtScriptBackend * engineBackend() const;
+    QList<DataStructurePtr>& dataStructures() const;
+    void remove(DataStructurePtr dataStructure);
+    void clear();
+    QRectF size();
+    virtual void cleanUpBeforeConvert();
+    DataStructurePluginInterface * backend() const;
+    void setBackend(const QString &pluginIdentifier);
+    void changeBackend();
+    int registerDataType(const QString &name, int identifier = 0);
+    int registerPointerType(const QString &name, int identifier = 0);
+    bool removeDataType(int dataType);
+    bool removePointerType(int pointerType);
+    PointerTypePtr pointerType(int pointerType) const;
+    DataTypePtr dataType(int dataType) const;
+    int groupType();
+    QList<int> dataTypeList() const;
+    QList<int> pointerTypeList() const;
+    QString iconPackage() const;
+public :
+    void setModified(const bool mod = true);
+    DataStructurePtr addDataStructure(const QString &name = QString());
+    DataStructurePtr addDataStructure(DataStructurePtr dataStructure);
+    DataStructurePtr activeDataStructure() const;
+    void setActiveDataStructure(int index);
+    void setActiveDataStructure(DataStructurePtr g);
+    void setLeft(qreal leftValue);
+    void setRight(qreal rightValue);
+    void setTop(qreal topValue);
+    void setBottom(qreal buttomValue);
+    qreal left() const;
+    qreal top() const;
+    qreal right() const;
+    qreal bottom() const;
+    qreal height() const;
+    qreal width() const;
+    void resizeDocumentIncrease();
+    void resizeDocumentBorder(Document::Border orientation);
+    void changeMinimalSize(qreal width, qreal height);
+    bool isPointAtDocument(qreal x, qreal y) const;
+    bool isPointAtDocument(const QPointF &point) const;
+protected:
+    void dataStructureCreated(DataStructurePtr g);
+    void dataStructureListChanged();
+    void dataTypeCreated(int identifier);
+    void pointerTypeCreated(int identifier);
+    void dataTypeRemoved(int identifier);
+    void pointerTypeRemoved(int identifier);
+    void nameChanged(QString name);
+    void heightChanged(qreal height);
+    void widthChanged(qreal width);
+    void activeDataStructureChanged(DataStructurePtr g);
+    void resized();
+private:
+    const boost::scoped_ptr<DocumentPrivate> d;
+    Document(const Document&);
+    Document& operator=(const Document&);
+};
+class Group;
+class Document;
+class Data;
+class Pointer;
+class DataStructurePrivate;
+class __attribute__ ((visibility("default"))) DataStructure : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    virtual ~DataStructure();
+    static DataStructurePtr create(Document *parent = 0);
+    static DataStructurePtr create(DataStructurePtr other, Document *parent = 0);
+    virtual DataStructurePtr getDataStructure() const;
+    void updateRelativeCenter();
+    QPointF relativeCenter() const;
+    Document *document() const;
+    void setReadOnly(bool r);
+    bool readOnly() const;
+    QScriptValue scriptValue() const;
+    virtual void setEngine(QScriptEngine *engine);
+    QScriptEngine *engine() const;
+    void updateData(DataPtr data);
+    void updatePointer(PointerPtr pointer);
+    bool isDataVisible(int dataType) const;
+    bool isPointerVisible(int pointerType) const;
+    QString name() const;
+    const DataList dataList(int dataType = 0) const;
+    DataList dataListAll() const;
+    const PointerList pointers(int pointerType = 0) const;
+    PointerList pointerListAll() const;
+    const QList<GroupPtr> groups() const;
+    virtual void cleanUpBeforeConvert();
+    virtual QMap<QString,QString> pluginProperties() const;
+    virtual void setPluginProperty(const QString& , const QString& );
+public :
+    virtual DataPtr addData(const QString& name, int dataType = 0);
+    virtual DataList addDataList(DataList dataList, int dataType = 0);
+    virtual PointerPtr addPointer(DataPtr from, DataPtr to, int pointerType = 0);
+    DataPtr getData(int uniqueIdentifier);
+    virtual void remove(DataPtr data);
+    virtual void remove(PointerPtr pointer);
+    virtual void remove(GroupPtr group);
+    virtual GroupPtr addGroup(const QString& name);
+    virtual DataList addDataList(QList< QPair<QString, QPointF> > dataList, int dataType = 0);
+    virtual DataPtr addData(const QString& name, const QPointF& point, int dataType = 0);
+    void addDynamicProperty(const QString& property, const QVariant& value = QVariant(0));
+    void removeDynamicProperty(const QString& property);
+    void renameDynamicProperty(const QString& oldName, const QString& newName);
+    void add_property(const QString& name, const QVariant& value);
+    void remove_property(const QString& name);
+    void addPointersDynamicProperty(const QString& property, const QVariant& value = QVariant(0));
+    void removePointersDynamicProperty(const QString& property);
+    void remove();
+    void setName(const QString& s);
+    void setDataColor(const QColor& color, int dataType);
+    void setDataVisibility(bool visible, int dataType);
+    void toggleDataVisibility(int dataType);
+    void setPointerColor(const QColor& color, int dataType);
+    void setPointerVisibility(bool visible, int pointerType);
+    void togglePointerVisibility(int pointerType);
+private :
+    void registerDataType(int identifier);
+    void registerPointerType(int identifier);
+    void removeDataType(int identifier);
+    void removePointerType(int identifier);
+protected:
+    void dataCreated(DataPtr n);
+    void pointerCreated(PointerPtr e);
+    void complexityChanged(bool directed);
+    void nameChanged(const QString& name);
+    void changed();
+    void resizeRequest(Document::Border border);
+protected:
+    DataPtr addData(DataPtr data, int dataType = 0);
+    PointerPtr addPointer(PointerPtr pointer, int pointerType = 0);
+    int generateUniqueIdentifier();
+protected:
+    DataStructure(Document *parent = 0);
+    virtual void importStructure(DataStructurePtr other);
+    void initialize();
+    template<typename T> static DataStructurePtr create(Document *parent = 0) {
+        DataStructurePtr pi(new T(parent));
+        pi->setQpointer(pi);
+        pi->initialize();
+        return pi;
+    }
+    template<typename T> static DataStructurePtr create(DataStructurePtr other, Document *parent = 0) {
+        DataStructurePtr pi(new T(parent));
+        pi->setQpointer(pi);
+        pi->initialize();
+        pi->importStructure(other);
+        return pi;
+    }
+private:
+    const boost::scoped_ptr<DataStructurePrivate> d;
+    DataStructure(const DataStructure&);
+    DataStructure& operator=(const DataStructure&);
+    void setQpointer(DataStructurePtr q);
+};
+namespace Rocs
+{
+class __attribute__ ((visibility("default"))) GraphStructure : public DataStructure
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    typedef enum {
+        Graph,
+        Multigraph
+    } GRAPH_TYPE;
+    using DataStructure::remove;
+    using DataStructure::addPointer;
+    using DataStructure::addData;
+    static DataStructurePtr create(Document *parent);
+    static DataStructurePtr create(DataStructurePtr other, Document *parent);
+    explicit GraphStructure(Document* parent = 0);
+    ~GraphStructure();
+    void importStructure(DataStructurePtr other);
+    PointerPtr addPointer(DataPtr from, DataPtr to, int pointerType = 0);
+    DataPtr addData(const QString& name, int dataType = 0);
+    GRAPH_TYPE graphType() const;
+    bool multigraph() const;
+    QMap<QString, QString> pluginProperties() const;
+    void setPluginProperty(const QString& identifier, const QString& property);
+    QMap<DataPtr,PointerList> dijkstraShortestPaths(DataPtr from);
+public :
+    void setGraphType(int type);
+    QScriptValue list_nodes();
+    QScriptValue list_nodes(int type);
+    QScriptValue list_edges();
+    QScriptValue list_edges(int type);
+    QScriptValue overlay_edges(int overlay);
+    QScriptValue add_node(const QString& name);
+    QScriptValue add_overlay_edge(Data* fromRaw, Data* toRaw, int overlay);
+    QScriptValue add_edge(Data* fromRaw, Data* toRaw);
+    QScriptValue dijkstra_shortest_path(Data* fromRaw, Data* toRaw);
+    QScriptValue distances(Data* fromRaw);
+private:
+    GraphStructure::GRAPH_TYPE _type;
+};
+}
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QPaintDevice;
+class QWidget;
+class QDialog;
+class QColor;
+class QPalette;
+class QCursor;
+class QPoint;
+class QSize;
+class QRect;
+class QPolygon;
+class QPainter;
+class QRegion;
+class QFont;
+class QFontMetrics;
+class QFontInfo;
+class QPen;
+class QBrush;
+class QMatrix;
+class QPixmap;
+class QBitmap;
+class QMovie;
+class QImage;
+class QPicture;
+class QPrinter;
+class QTimer;
+class QTime;
+class QClipboard;
+class QString;
+class QByteArray;
+class QApplication;
+template<typename T> class QList;
+typedef QList<QWidget *> QWidgetList;
+typedef struct _XDisplay Display;
+typedef union _XEvent XEvent;
+typedef struct _XGC *GC;
+typedef struct _XRegion *Region;
+typedef unsigned long WId;
+template<class K, class V> class QHash;
+typedef QHash<WId, QWidget *> QWidgetMapper;
+template<class V> class QSet;
+typedef QSet<QWidget *> QWidgetSet;
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QPaintEngine;
+class QPaintDevice
+{
+public:
+    enum PaintDeviceMetric {
+        PdmWidth = 1,
+        PdmHeight,
+        PdmWidthMM,
+        PdmHeightMM,
+        PdmNumColors,
+        PdmDepth,
+        PdmDpiX,
+        PdmDpiY,
+        PdmPhysicalDpiX,
+        PdmPhysicalDpiY
+    };
+    virtual ~QPaintDevice();
+    virtual int devType() const;
+    bool paintingActive() const;
+    virtual QPaintEngine *paintEngine() const = 0;
+    int width() const { return metric(PdmWidth); }
+    int height() const { return metric(PdmHeight); }
+    int widthMM() const { return metric(PdmWidthMM); }
+    int heightMM() const { return metric(PdmHeightMM); }
+    int logicalDpiX() const { return metric(PdmDpiX); }
+    int logicalDpiY() const { return metric(PdmDpiY); }
+    int physicalDpiX() const { return metric(PdmPhysicalDpiX); }
+    int physicalDpiY() const { return metric(PdmPhysicalDpiY); }
+    int numColors() const { return metric(PdmNumColors); }
+    int colorCount() const { return metric(PdmNumColors); }
+    int depth() const { return metric(PdmDepth); }
+protected:
+    QPaintDevice();
+    virtual int metric(PaintDeviceMetric metric) const;
+    ushort painters;
+private:
+    QPaintDevice(const QPaintDevice &); QPaintDevice &operator=(const QPaintDevice &);
+    friend class QPainter;
+    friend class QFontEngineMac;
+    friend class QX11PaintEngine;
+    friend int qt_paint_device_metric(const QPaintDevice *device, PaintDeviceMetric metric);
+};
+inline int QPaintDevice::devType() const
+{ return QInternal::UnknownDevice; }
+inline bool QPaintDevice::paintingActive() const
+{ return painters != 0; }
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QMatrix;
+class QTransform;
+class QRect;
+class QVariant;
+class QPolygon : public QVector<QPoint>
+{
+public:
+    inline QPolygon() {}
+    inline ~QPolygon() {}
+    inline QPolygon(int size);
+    inline QPolygon(const QPolygon &a) : QVector<QPoint>(a) {}
+    inline QPolygon(const QVector<QPoint> &v) : QVector<QPoint>(v) {}
+    QPolygon(const QRect &r, bool closed=false);
+    QPolygon(int nPoints, const int *points);
+    inline void swap(QPolygon &other) { QVector<QPoint>::swap(other); }
+    operator QVariant() const;
+    void translate(int dx, int dy);
+    void translate(const QPoint &offset);
+    QPolygon translated(int dx, int dy) const;
+    inline QPolygon translated(const QPoint &offset) const;
+    QRect boundingRect() const;
+    void point(int i, int *x, int *y) const;
+    QPoint point(int i) const;
+    void setPoint(int index, int x, int y);
+    void setPoint(int index, const QPoint &p);
+    void setPoints(int nPoints, const int *points);
+    void setPoints(int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const int *points);
+    void putPoints(int index, int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const QPolygon & from, int fromIndex=0);
+    bool containsPoint(const QPoint &pt, Qt::FillRule fillRule) const;
+    QPolygon united(const QPolygon &r) const;
+    QPolygon intersected(const QPolygon &r) const;
+    QPolygon subtracted(const QPolygon &r) const;
+};
+inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}
+ QDebug operator<<(QDebug, const QPolygon &);
+ QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon);
+ QDataStream &operator>>(QDataStream &stream, QPolygon &polygon);
+inline void QPolygon::setPoint(int index, const QPoint &pt)
+{ (*this)[index] = pt; }
+inline void QPolygon::setPoint(int index, int x, int y)
+{ (*this)[index] = QPoint(x, y); }
+inline QPoint QPolygon::point(int index) const
+{ return at(index); }
+inline void QPolygon::translate(const QPoint &offset)
+{ translate(offset.x(), offset.y()); }
+inline QPolygon QPolygon::translated(const QPoint &offset) const
+{ return translated(offset.x(), offset.y()); }
+class QRectF;
+class QPolygonF : public QVector<QPointF>
+{
+public:
+    inline QPolygonF() {}
+    inline ~QPolygonF() {}
+    inline QPolygonF(int size);
+    inline QPolygonF(const QPolygonF &a) : QVector<QPointF>(a) {}
+    inline QPolygonF(const QVector<QPointF> &v) : QVector<QPointF>(v) {}
+    QPolygonF(const QRectF &r);
+    QPolygonF(const QPolygon &a);
+    inline void swap(QPolygonF &other) { QVector<QPointF>::swap(other); }
+    inline void translate(qreal dx, qreal dy);
+    void translate(const QPointF &offset);
+    inline QPolygonF translated(qreal dx, qreal dy) const;
+    QPolygonF translated(const QPointF &offset) const;
+    QPolygon toPolygon() const;
+    bool isClosed() const { return !isEmpty() && first() == last(); }
+    QRectF boundingRect() const;
+    bool containsPoint(const QPointF &pt, Qt::FillRule fillRule) const;
+    QPolygonF united(const QPolygonF &r) const;
+    QPolygonF intersected(const QPolygonF &r) const;
+    QPolygonF subtracted(const QPolygonF &r) const;
+};
+inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {}
+ QDebug operator<<(QDebug, const QPolygonF &);
+ QDataStream &operator<<(QDataStream &stream, const QPolygonF &array);
+ QDataStream &operator>>(QDataStream &stream, QPolygonF &array);
+inline void QPolygonF::translate(qreal dx, qreal dy)
+{ translate(QPointF(dx, dy)); }
+inline QPolygonF QPolygonF::translated(qreal dx, qreal dy) const
+{ return translated(QPointF(dx, dy)); }
+typedef QtValidLicenseForGuiModule QtGuiModule;
+template <class T> class QVector;
+class QVariant;
+struct QRegionPrivate;
+class QBitmap;
+class QRegion
+{
+public:
+    enum RegionType { Rectangle, Ellipse };
+    QRegion();
+    QRegion(int x, int y, int w, int h, RegionType t = Rectangle);
+    QRegion(const QRect &r, RegionType t = Rectangle);
+    QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill);
+    QRegion(const QRegion &region);
+    QRegion(const QBitmap &bitmap);
+    ~QRegion();
+    QRegion &operator=(const QRegion &);
+    inline void swap(QRegion &other) { qSwap(d, other.d); }
+    bool isEmpty() const;
+    bool contains(const QPoint &p) const;
+    bool contains(const QRect &r) const;
+    void translate(int dx, int dy);
+    inline void translate(const QPoint &p) { translate(p.x(), p.y()); }
+    QRegion translated(int dx, int dy) const;
+    inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); }
+    QRegion unite(const QRegion &r) const;
+    QRegion unite(const QRect &r) const;
+    QRegion intersect(const QRegion &r) const;
+    QRegion intersect(const QRect &r) const;
+    QRegion subtract(const QRegion &r) const;
+    QRegion eor(const QRegion &r) const;
+    inline QRegion united(const QRegion &r) const { return unite(r); }
+    inline QRegion united(const QRect &r) const { return unite(r); }
+    inline QRegion intersected(const QRegion &r) const { return intersect(r); }
+    inline QRegion intersected(const QRect &r) const { return intersect(r); }
+    inline QRegion subtracted(const QRegion &r) const { return subtract(r); }
+    inline QRegion xored(const QRegion &r) const { return eor(r); }
+    bool intersects(const QRegion &r) const;
+    bool intersects(const QRect &r) const;
+    QRect boundingRect() const;
+    QVector<QRect> rects() const;
+    void setRects(const QRect *rect, int num);
+    int numRects() const;
+    int rectCount() const;
+    const QRegion operator|(const QRegion &r) const;
+    const QRegion operator+(const QRegion &r) const;
+    const QRegion operator+(const QRect &r) const;
+    const QRegion operator&(const QRegion &r) const;
+    const QRegion operator&(const QRect &r) const;
+    const QRegion operator-(const QRegion &r) const;
+    const QRegion operator^(const QRegion &r) const;
+    QRegion& operator|=(const QRegion &r);
+    QRegion& operator+=(const QRegion &r);
+    QRegion& operator+=(const QRect &r);
+    QRegion& operator&=(const QRegion &r);
+    QRegion& operator&=(const QRect &r);
+    QRegion& operator-=(const QRegion &r);
+    QRegion& operator^=(const QRegion &r);
+    bool operator==(const QRegion &r) const;
+    inline bool operator!=(const QRegion &r) const { return !(operator==(r)); }
+    operator QVariant() const;
+    inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; }
+    friend QDataStream &operator<<(QDataStream &, const QRegion &);
+    friend QDataStream &operator>>(QDataStream &, QRegion &);
+private:
+    QRegion copy() const;
+    void detach();
+    void updateX11Region() const;
+    void *clipRectangles(int &num) const;
+    friend void *qt_getClipRects(const QRegion &r, int &num);
+    friend bool qt_region_strictContains(const QRegion &region,
+                                         const QRect &rect);
+    friend struct QRegionPrivate;
+    void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian);
+    struct QRegionData {
+        QBasicAtomicInt ref;
+        Region rgn;
+        void *xrectangles;
+        QRegionPrivate *qt_rgn;
+    };
+    struct QRegionData *d;
+    static struct QRegionData shared_empty;
+    static void cleanUp(QRegionData *x);
+};
+ QDataStream &operator<<(QDataStream &, const QRegion &);
+ QDataStream &operator>>(QDataStream &, QRegion &);
+ QDebug operator<<(QDebug, const QRegion &);
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QPainterPath;
+class QVariant;
+class QMatrix
+{
+public:
+    inline explicit QMatrix(Qt::Initialization) {}
+    QMatrix();
+    QMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+            qreal dx, qreal dy);
+    QMatrix(const QMatrix &matrix);
+    void setMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+                   qreal dx, qreal dy);
+    qreal m11() const { return _m11; }
+    qreal m12() const { return _m12; }
+    qreal m21() const { return _m21; }
+    qreal m22() const { return _m22; }
+    qreal dx() const { return _dx; }
+    qreal dy() const { return _dy; }
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+    QPoint map(const QPoint &p) const;
+    QPointF map(const QPointF&p) const;
+    QLine map(const QLine &l) const;
+    QLineF map(const QLineF &l) const;
+    QPolygonF map(const QPolygonF &a) const;
+    QPolygon map(const QPolygon &a) const;
+    QRegion map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon mapToPolygon(const QRect &r) const;
+    void reset();
+    inline bool isIdentity() const;
+    QMatrix &translate(qreal dx, qreal dy);
+    QMatrix &scale(qreal sx, qreal sy);
+    QMatrix &shear(qreal sh, qreal sv);
+    QMatrix &rotate(qreal a);
+    bool isInvertible() const { return !qFuzzyIsNull(_m11*_m22 - _m12*_m21); }
+    qreal determinant() const { return _m11*_m22 - _m12*_m21; }
+    qreal det() const { return _m11*_m22 - _m12*_m21; }
+    QMatrix inverted(bool *invertible = 0) const;
+    bool operator==(const QMatrix &) const;
+    bool operator!=(const QMatrix &) const;
+    QMatrix &operator*=(const QMatrix &);
+    QMatrix operator*(const QMatrix &o) const;
+    QMatrix &operator=(const QMatrix &);
+    operator QVariant() const;
+private:
+    inline QMatrix(bool)
+            : _m11(1.)
+            , _m12(0.)
+            , _m21(0.)
+            , _m22(1.)
+            , _dx(0.)
+            , _dy(0.) {}
+    inline QMatrix(qreal am11, qreal am12, qreal am21, qreal am22, qreal adx, qreal ady, bool)
+            : _m11(am11)
+            , _m12(am12)
+            , _m21(am21)
+            , _m22(am22)
+            , _dx(adx)
+            , _dy(ady) {}
+    friend class QTransform;
+    qreal _m11, _m12;
+    qreal _m21, _m22;
+    qreal _dx, _dy;
+};
+template<> class QTypeInfo<QMatrix > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMatrix)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMatrix"; } };
+ inline QPoint operator*(const QPoint &p, const QMatrix &m)
+{ return m.map(p); }
+ inline QPointF operator*(const QPointF &p, const QMatrix &m)
+{ return m.map(p); }
+ inline QLineF operator*(const QLineF &l, const QMatrix &m)
+{ return m.map(l); }
+ inline QLine operator*(const QLine &l, const QMatrix &m)
+{ return m.map(l); }
+ inline QPolygon operator *(const QPolygon &a, const QMatrix &m)
+{ return m.map(a); }
+ inline QPolygonF operator *(const QPolygonF &a, const QMatrix &m)
+{ return m.map(a); }
+ inline QRegion operator *(const QRegion &r, const QMatrix &m)
+{ return m.map(r); }
+ QPainterPath operator *(const QPainterPath &p, const QMatrix &m);
+inline bool QMatrix::isIdentity() const
+{
+    return qFuzzyIsNull(_m11 - 1) && qFuzzyIsNull(_m22 - 1) && qFuzzyIsNull(_m12)
+           && qFuzzyIsNull(_m21) && qFuzzyIsNull(_dx) && qFuzzyIsNull(_dy);
+}
+inline bool qFuzzyCompare(const QMatrix& m1, const QMatrix& m2)
+{
+    return qFuzzyCompare(m1.m11(), m2.m11())
+        && qFuzzyCompare(m1.m12(), m2.m12())
+        && qFuzzyCompare(m1.m21(), m2.m21())
+        && qFuzzyCompare(m1.m22(), m2.m22())
+        && qFuzzyCompare(m1.dx(), m2.dx())
+        && qFuzzyCompare(m1.dy(), m2.dy());
+}
+ QDataStream &operator<<(QDataStream &, const QMatrix &);
+ QDataStream &operator>>(QDataStream &, QMatrix &);
+ QDebug operator<<(QDebug, const QMatrix &);
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QFont;
+class QPainterPathPrivate;
+struct QPainterPathPrivateDeleter;
+class QPainterPathData;
+class QPainterPathStrokerPrivate;
+class QPolygonF;
+class QRegion;
+class QVectorPath;
+class QPainterPath
+{
+public:
+    enum ElementType {
+        MoveToElement,
+        LineToElement,
+        CurveToElement,
+        CurveToDataElement
+    };
+    class Element {
+    public:
+        qreal x;
+        qreal y;
+        ElementType type;
+        bool isMoveTo() const { return type == MoveToElement; }
+        bool isLineTo() const { return type == LineToElement; }
+        bool isCurveTo() const { return type == CurveToElement; }
+        operator QPointF () const { return QPointF(x, y); }
+        bool operator==(const Element &e) const { return qFuzzyCompare(x, e.x)
+            && qFuzzyCompare(y, e.y) && type == e.type; }
+        inline bool operator!=(const Element &e) const { return !operator==(e); }
+    };
+    QPainterPath();
+    explicit QPainterPath(const QPointF &startPoint);
+    QPainterPath(const QPainterPath &other);
+    QPainterPath &operator=(const QPainterPath &other);
+    ~QPainterPath();
+    inline void swap(QPainterPath &other) { d_ptr.swap(other.d_ptr); }
+    void closeSubpath();
+    void moveTo(const QPointF &p);
+    inline void moveTo(qreal x, qreal y);
+    void lineTo(const QPointF &p);
+    inline void lineTo(qreal x, qreal y);
+    void arcMoveTo(const QRectF &rect, qreal angle);
+    inline void arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle);
+    void arcTo(const QRectF &rect, qreal startAngle, qreal arcLength);
+    inline void arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength);
+    void cubicTo(const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt);
+    inline void cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                        qreal endPtx, qreal endPty);
+    void quadTo(const QPointF &ctrlPt, const QPointF &endPt);
+    inline void quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty);
+    QPointF currentPosition() const;
+    void addRect(const QRectF &rect);
+    inline void addRect(qreal x, qreal y, qreal w, qreal h);
+    void addEllipse(const QRectF &rect);
+    inline void addEllipse(qreal x, qreal y, qreal w, qreal h);
+    inline void addEllipse(const QPointF &center, qreal rx, qreal ry);
+    void addPolygon(const QPolygonF &polygon);
+    void addText(const QPointF &point, const QFont &f, const QString &text);
+    inline void addText(qreal x, qreal y, const QFont &f, const QString &text);
+    void addPath(const QPainterPath &path);
+    void addRegion(const QRegion &region);
+    void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                        Qt::SizeMode mode = Qt::AbsoluteSize);
+    inline void addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                               qreal xRadius, qreal yRadius,
+                               Qt::SizeMode mode = Qt::AbsoluteSize);
+    void addRoundRect(const QRectF &rect, int xRnd, int yRnd);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int xRnd, int yRnd);
+    inline void addRoundRect(const QRectF &rect, int roundness);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int roundness);
+    void connectPath(const QPainterPath &path);
+    bool contains(const QPointF &pt) const;
+    bool contains(const QRectF &rect) const;
+    bool intersects(const QRectF &rect) const;
+    void translate(qreal dx, qreal dy);
+    inline void translate(const QPointF &offset);
+    QPainterPath translated(qreal dx, qreal dy) const;
+    inline QPainterPath translated(const QPointF &offset) const;
+    QRectF boundingRect() const;
+    QRectF controlPointRect() const;
+    Qt::FillRule fillRule() const;
+    void setFillRule(Qt::FillRule fillRule);
+    inline bool isEmpty() const;
+    QPainterPath toReversed() const;
+    QList<QPolygonF> toSubpathPolygons(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toFillPolygons(const QMatrix &matrix = QMatrix()) const;
+    QPolygonF toFillPolygon(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toSubpathPolygons(const QTransform &matrix) const;
+    QList<QPolygonF> toFillPolygons(const QTransform &matrix) const;
+    QPolygonF toFillPolygon(const QTransform &matrix) const;
+    inline int elementCount() const;
+    inline const QPainterPath::Element &elementAt(int i) const;
+    inline void setElementPositionAt(int i, qreal x, qreal y);
+    qreal length() const;
+    qreal percentAtLength(qreal t) const;
+    QPointF pointAtPercent(qreal t) const;
+    qreal angleAtPercent(qreal t) const;
+    qreal slopeAtPercent(qreal t) const;
+    bool intersects(const QPainterPath &p) const;
+    bool contains(const QPainterPath &p) const;
+    QPainterPath united(const QPainterPath &r) const;
+    QPainterPath intersected(const QPainterPath &r) const;
+    QPainterPath subtracted(const QPainterPath &r) const;
+    QPainterPath subtractedInverted(const QPainterPath &r) const;
+    QPainterPath simplified() const;
+    bool operator==(const QPainterPath &other) const;
+    bool operator!=(const QPainterPath &other) const;
+    QPainterPath operator&(const QPainterPath &other) const;
+    QPainterPath operator|(const QPainterPath &other) const;
+    QPainterPath operator+(const QPainterPath &other) const;
+    QPainterPath operator-(const QPainterPath &other) const;
+    QPainterPath &operator&=(const QPainterPath &other);
+    QPainterPath &operator|=(const QPainterPath &other);
+    QPainterPath &operator+=(const QPainterPath &other);
+    QPainterPath &operator-=(const QPainterPath &other);
+private:
+    QScopedPointer<QPainterPathPrivate, QPainterPathPrivateDeleter> d_ptr;
+    inline void ensureData() { if (!d_ptr) ensureData_helper(); }
+    void ensureData_helper();
+    inline void detach();
+    void detach_helper();
+    void setDirty(bool);
+    void computeBoundingRect() const;
+    void computeControlPointRect() const;
+    QPainterPathData *d_func() const { return reinterpret_cast<QPainterPathData *>(d_ptr.data()); }
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend const QVectorPath &qtVectorPathForPath(const QPainterPath &);
+    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend QDataStream &operator>>(QDataStream &, QPainterPath &);
+};
+class QPainterPathPrivate
+{
+public:
+    friend class QPainterPath;
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend struct QPainterPathPrivateDeleter;
+    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend QDataStream &operator>>(QDataStream &, QPainterPath &);
+private:
+    QAtomicInt ref;
+    QVector<QPainterPath::Element> elements;
+};
+template<> class QTypeInfo<QPainterPath::Element > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPainterPath::Element)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPainterPath::Element"; } };
+ QDataStream &operator<<(QDataStream &, const QPainterPath &);
+ QDataStream &operator>>(QDataStream &, QPainterPath &);
+class QPainterPathStroker
+{
+    inline QPainterPathStrokerPrivate* d_func() { return reinterpret_cast<QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } inline const QPainterPathStrokerPrivate* d_func() const { return reinterpret_cast<const QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } friend class QPainterPathStrokerPrivate;
+public:
+    QPainterPathStroker();
+    ~QPainterPathStroker();
+    void setWidth(qreal width);
+    qreal width() const;
+    void setCapStyle(Qt::PenCapStyle style);
+    Qt::PenCapStyle capStyle() const;
+    void setJoinStyle(Qt::PenJoinStyle style);
+    Qt::PenJoinStyle joinStyle() const;
+    void setMiterLimit(qreal length);
+    qreal miterLimit() const;
+    void setCurveThreshold(qreal threshold);
+    qreal curveThreshold() const;
+    void setDashPattern(Qt::PenStyle);
+    void setDashPattern(const QVector<qreal> &dashPattern);
+    QVector<qreal> dashPattern() const;
+    void setDashOffset(qreal offset);
+    qreal dashOffset() const;
+    QPainterPath createStroke(const QPainterPath &path) const;
+private:
+    QPainterPathStroker(const QPainterPathStroker &); QPainterPathStroker &operator=(const QPainterPathStroker &);
+    friend class QX11PaintEngine;
+    QScopedPointer<QPainterPathStrokerPrivate> d_ptr;
+};
+inline void QPainterPath::moveTo(qreal x, qreal y)
+{
+    moveTo(QPointF(x, y));
+}
+inline void QPainterPath::lineTo(qreal x, qreal y)
+{
+    lineTo(QPointF(x, y));
+}
+inline void QPainterPath::arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
+{
+    arcTo(QRectF(x, y, w, h), startAngle, arcLength);
+}
+inline void QPainterPath::arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle)
+{
+    arcMoveTo(QRectF(x, y, w, h), angle);
+}
+inline void QPainterPath::cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                                   qreal endPtx, qreal endPty)
+{
+    cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y),
+            QPointF(endPtx, endPty));
+}
+inline void QPainterPath::quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
+{
+    quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty));
+}
+inline void QPainterPath::addEllipse(qreal x, qreal y, qreal w, qreal h)
+{
+    addEllipse(QRectF(x, y, w, h));
+}
+inline void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
+{
+    addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
+}
+inline void QPainterPath::addRect(qreal x, qreal y, qreal w, qreal h)
+{
+    addRect(QRectF(x, y, w, h));
+}
+inline void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                                         qreal xRadius, qreal yRadius,
+                                         Qt::SizeMode mode)
+{
+    addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
+}
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int xRnd, int yRnd)
+{
+    addRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
+}
+inline void QPainterPath::addRoundRect(const QRectF &rect,
+                                       int roundness)
+{
+    int xRnd = roundness;
+    int yRnd = roundness;
+    if (rect.width() > rect.height())
+        xRnd = int(roundness * rect.height()/rect.width());
+    else
+        yRnd = int(roundness * rect.width()/rect.height());
+    addRoundRect(rect, xRnd, yRnd);
+}
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int roundness)
+{
+    addRoundRect(QRectF(x, y, w, h), roundness);
+}
+inline void QPainterPath::addText(qreal x, qreal y, const QFont &f, const QString &text)
+{
+    addText(QPointF(x, y), f, text);
+}
+inline void QPainterPath::translate(const QPointF &offset)
+{ translate(offset.x(), offset.y()); }
+inline QPainterPath QPainterPath::translated(const QPointF &offset) const
+{ return translated(offset.x(), offset.y()); }
+inline bool QPainterPath::isEmpty() const
+{
+    return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
+}
+inline int QPainterPath::elementCount() const
+{
+    return d_ptr ? d_ptr->elements.size() : 0;
+}
+inline const QPainterPath::Element &QPainterPath::elementAt(int i) const
+{
+    qt_noop();
+    qt_noop();
+    return d_ptr->elements.at(i);
+}
+inline void QPainterPath::setElementPositionAt(int i, qreal x, qreal y)
+{
+    qt_noop();
+    qt_noop();
+    detach();
+    QPainterPath::Element &e = d_ptr->elements[i];
+    e.x = x;
+    e.y = y;
+}
+inline void QPainterPath::detach()
+{
+    if (d_ptr->ref != 1)
+        detach_helper();
+    setDirty(true);
+}
+ QDebug operator<<(QDebug, const QPainterPath &);
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QVariant;
+class QTransform
+{
+public:
+    enum TransformationType {
+        TxNone = 0x00,
+        TxTranslate = 0x01,
+        TxScale = 0x02,
+        TxRotate = 0x04,
+        TxShear = 0x08,
+        TxProject = 0x10
+    };
+    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}
+    QTransform();
+    QTransform(qreal h11, qreal h12, qreal h13,
+               qreal h21, qreal h22, qreal h23,
+               qreal h31, qreal h32, qreal h33 = 1.0);
+    QTransform(qreal h11, qreal h12, qreal h21,
+               qreal h22, qreal dx, qreal dy);
+    explicit QTransform(const QMatrix &mtx);
+    bool isAffine() const;
+    bool isIdentity() const;
+    bool isInvertible() const;
+    bool isScaling() const;
+    bool isRotating() const;
+    bool isTranslating() const;
+    TransformationType type() const;
+    inline qreal determinant() const;
+    qreal det() const;
+    qreal m11() const;
+    qreal m12() const;
+    qreal m13() const;
+    qreal m21() const;
+    qreal m22() const;
+    qreal m23() const;
+    qreal m31() const;
+    qreal m32() const;
+    qreal m33() const;
+    qreal dx() const;
+    qreal dy() const;
+    void setMatrix(qreal m11, qreal m12, qreal m13,
+                   qreal m21, qreal m22, qreal m23,
+                   qreal m31, qreal m32, qreal m33);
+    QTransform inverted(bool *invertible = 0) const;
+    QTransform adjoint() const;
+    QTransform transposed() const;
+    QTransform &translate(qreal dx, qreal dy);
+    QTransform &scale(qreal sx, qreal sy);
+    QTransform &shear(qreal sh, qreal sv);
+    QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis);
+    QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis);
+    static bool squareToQuad(const QPolygonF &square, QTransform &result);
+    static bool quadToSquare(const QPolygonF &quad, QTransform &result);
+    static bool quadToQuad(const QPolygonF &one,
+                           const QPolygonF &two,
+                           QTransform &result);
+    bool operator==(const QTransform &) const;
+    bool operator!=(const QTransform &) const;
+    QTransform &operator*=(const QTransform &);
+    QTransform operator*(const QTransform &o) const;
+    QTransform &operator=(const QTransform &);
+    operator QVariant() const;
+    void reset();
+    QPoint map(const QPoint &p) const;
+    QPointF map(const QPointF &p) const;
+    QLine map(const QLine &l) const;
+    QLineF map(const QLineF &l) const;
+    QPolygonF map(const QPolygonF &a) const;
+    QPolygon map(const QPolygon &a) const;
+    QRegion map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon mapToPolygon(const QRect &r) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+    const QMatrix &toAffine() const;
+    QTransform &operator*=(qreal div);
+    QTransform &operator/=(qreal div);
+    QTransform &operator+=(qreal div);
+    QTransform &operator-=(qreal div);
+    static QTransform fromTranslate(qreal dx, qreal dy);
+    static QTransform fromScale(qreal dx, qreal dy);
+private:
+    inline QTransform(qreal h11, qreal h12, qreal h13,
+                      qreal h21, qreal h22, qreal h23,
+                      qreal h31, qreal h32, qreal h33, bool)
+        : affine(h11, h12, h21, h22, h31, h32, true)
+        , m_13(h13), m_23(h23), m_33(h33)
+        , m_type(TxNone)
+        , m_dirty(TxProject) {}
+    inline QTransform(bool)
+        : affine(true)
+        , m_13(0), m_23(0), m_33(1)
+        , m_type(TxNone)
+        , m_dirty(TxNone) {}
+    inline TransformationType inline_type() const;
+    QMatrix affine;
+    qreal m_13;
+    qreal m_23;
+    qreal m_33;
+    mutable uint m_type : 5;
+    mutable uint m_dirty : 5;
+    class Private;
+    Private *d;
+};
+template<> class QTypeInfo<QTransform > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTransform)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTransform"; } };
+inline QTransform::TransformationType QTransform::inline_type() const
+{
+    if (m_dirty == TxNone)
+        return static_cast<TransformationType>(m_type);
+    return type();
+}
+inline bool QTransform::isAffine() const
+{
+    return inline_type() < TxProject;
+}
+inline bool QTransform::isIdentity() const
+{
+    return inline_type() == TxNone;
+}
+inline bool QTransform::isInvertible() const
+{
+    return !qFuzzyIsNull(determinant());
+}
+inline bool QTransform::isScaling() const
+{
+    return type() >= TxScale;
+}
+inline bool QTransform::isRotating() const
+{
+    return inline_type() >= TxRotate;
+}
+inline bool QTransform::isTranslating() const
+{
+    return inline_type() >= TxTranslate;
+}
+inline qreal QTransform::determinant() const
+{
+    return affine._m11*(m_33*affine._m22-affine._dy*m_23) -
+        affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13);
+}
+inline qreal QTransform::det() const
+{
+    return determinant();
+}
+inline qreal QTransform::m11() const
+{
+    return affine._m11;
+}
+inline qreal QTransform::m12() const
+{
+    return affine._m12;
+}
+inline qreal QTransform::m13() const
+{
+    return m_13;
+}
+inline qreal QTransform::m21() const
+{
+    return affine._m21;
+}
+inline qreal QTransform::m22() const
+{
+    return affine._m22;
+}
+inline qreal QTransform::m23() const
+{
+    return m_23;
+}
+inline qreal QTransform::m31() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::m32() const
+{
+    return affine._dy;
+}
+inline qreal QTransform::m33() const
+{
+    return m_33;
+}
+inline qreal QTransform::dx() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::dy() const
+{
+    return affine._dy;
+}
+inline QTransform &QTransform::operator*=(qreal num)
+{
+    if (num == 1.)
+        return *this;
+    affine._m11 *= num;
+    affine._m12 *= num;
+    m_13 *= num;
+    affine._m21 *= num;
+    affine._m22 *= num;
+    m_23 *= num;
+    affine._dx *= num;
+    affine._dy *= num;
+    m_33 *= num;
+    if (m_dirty < TxScale)
+        m_dirty = TxScale;
+    return *this;
+}
+inline QTransform &QTransform::operator/=(qreal div)
+{
+    if (div == 0)
+        return *this;
+    div = 1/div;
+    return operator*=(div);
+}
+inline QTransform &QTransform::operator+=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 += num;
+    affine._m12 += num;
+    m_13 += num;
+    affine._m21 += num;
+    affine._m22 += num;
+    m_23 += num;
+    affine._dx += num;
+    affine._dy += num;
+    m_33 += num;
+    m_dirty = TxProject;
+    return *this;
+}
+inline QTransform &QTransform::operator-=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 -= num;
+    affine._m12 -= num;
+    m_13 -= num;
+    affine._m21 -= num;
+    affine._m22 -= num;
+    m_23 -= num;
+    affine._dx -= num;
+    affine._dy -= num;
+    m_33 -= num;
+    m_dirty = TxProject;
+    return *this;
+}
+inline bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)
+{
+    return qFuzzyCompare(t1.m11(), t2.m11())
+        && qFuzzyCompare(t1.m12(), t2.m12())
+        && qFuzzyCompare(t1.m13(), t2.m13())
+        && qFuzzyCompare(t1.m21(), t2.m21())
+        && qFuzzyCompare(t1.m22(), t2.m22())
+        && qFuzzyCompare(t1.m23(), t2.m23())
+        && qFuzzyCompare(t1.m31(), t2.m31())
+        && qFuzzyCompare(t1.m32(), t2.m32())
+        && qFuzzyCompare(t1.m33(), t2.m33());
+}
+ QDataStream &operator<<(QDataStream &, const QTransform &);
+ QDataStream &operator>>(QDataStream &, QTransform &);
+ QDebug operator<<(QDebug, const QTransform &);
+ inline QPoint operator*(const QPoint &p, const QTransform &m)
+{ return m.map(p); }
+ inline QPointF operator*(const QPointF &p, const QTransform &m)
+{ return m.map(p); }
+ inline QLineF operator*(const QLineF &l, const QTransform &m)
+{ return m.map(l); }
+ inline QLine operator*(const QLine &l, const QTransform &m)
+{ return m.map(l); }
+ inline QPolygon operator *(const QPolygon &a, const QTransform &m)
+{ return m.map(a); }
+ inline QPolygonF operator *(const QPolygonF &a, const QTransform &m)
+{ return m.map(a); }
+ inline QRegion operator *(const QRegion &r, const QTransform &m)
+{ return m.map(r); }
+ inline QPainterPath operator *(const QPainterPath &p, const QTransform &m)
+{ return m.map(p); }
+ inline QTransform operator *(const QTransform &a, qreal n)
+{ QTransform t(a); t *= n; return t; }
+ inline QTransform operator /(const QTransform &a, qreal n)
+{ QTransform t(a); t /= n; return t; }
+ inline QTransform operator +(const QTransform &a, qreal n)
+{ QTransform t(a); t += n; return t; }
+ inline QTransform operator -(const QTransform &a, qreal n)
+{ QTransform t(a); t -= n; return t; }
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QIODevice;
+class QStringList;
+class QMatrix;
+class QTransform;
+class QVariant;
+template <class T> class QList;
+template <class T> class QVector;
+struct QImageData;
+class QImageDataMisc;
+class QImageTextKeyLang {
+public:
+    QImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { }
+    QImageTextKeyLang() { }
+    QByteArray key;
+    QByteArray lang;
+    bool operator< (const QImageTextKeyLang& other) const
+        { return key < other.key || (key==other.key && lang < other.lang); }
+    bool operator== (const QImageTextKeyLang& other) const
+        { return key==other.key && lang==other.lang; }
+    inline bool operator!= (const QImageTextKeyLang &other) const
+        { return !operator==(other); }
+};
+class QImage : public QPaintDevice
+{
+public:
+    enum InvertMode { InvertRgb, InvertRgba };
+    enum Format {
+        Format_Invalid,
+        Format_Mono,
+        Format_MonoLSB,
+        Format_Indexed8,
+        Format_RGB32,
+        Format_ARGB32,
+        Format_ARGB32_Premultiplied,
+        Format_RGB16,
+        Format_ARGB8565_Premultiplied,
+        Format_RGB666,
+        Format_ARGB6666_Premultiplied,
+        Format_RGB555,
+        Format_ARGB8555_Premultiplied,
+        Format_RGB888,
+        Format_RGB444,
+        Format_ARGB4444_Premultiplied,
+        NImageFormats
+    };
+    QImage();
+    QImage(const QSize &size, Format format);
+    QImage(int width, int height, Format format);
+    QImage(uchar *data, int width, int height, Format format);
+    QImage(const uchar *data, int width, int height, Format format);
+    QImage(uchar *data, int width, int height, int bytesPerLine, Format format);
+    QImage(const uchar *data, int width, int height, int bytesPerLine, Format format);
+    explicit QImage(const char * const xpm[]);
+    explicit QImage(const QString &fileName, const char *format = 0);
+    explicit QImage(const char *fileName, const char *format = 0);
+    QImage(const QImage &);
+    ~QImage();
+    QImage &operator=(const QImage &);
+    inline void swap(QImage &other) { qSwap(d, other.d); }
+    bool isNull() const;
+    int devType() const;
+    bool operator==(const QImage &) const;
+    bool operator!=(const QImage &) const;
+    operator QVariant() const;
+    void detach();
+    bool isDetached() const;
+    QImage copy(const QRect &rect = QRect()) const;
+    inline QImage copy(int x, int y, int w, int h) const
+        { return copy(QRect(x, y, w, h)); }
+    Format format() const;
+    QImage convertToFormat(Format f, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result));
+    QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result));
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+    int depth() const;
+    int numColors() const;
+    int colorCount() const;
+    int bitPlaneCount() const;
+    QRgb color(int i) const;
+    void setColor(int i, QRgb c);
+    void setNumColors(int);
+    void setColorCount(int);
+    bool allGray() const;
+    bool isGrayscale() const;
+    uchar *bits();
+    const uchar *bits() const;
+    const uchar *constBits() const;
+    int numBytes() const;
+    int byteCount() const;
+    uchar *scanLine(int);
+    const uchar *scanLine(int) const;
+    const uchar *constScanLine(int) const;
+    int bytesPerLine() const;
+    bool valid(int x, int y) const;
+    bool valid(const QPoint &pt) const;
+    int pixelIndex(int x, int y) const;
+    int pixelIndex(const QPoint &pt) const;
+    QRgb pixel(int x, int y) const;
+    QRgb pixel(const QPoint &pt) const;
+    void setPixel(int x, int y, uint index_or_rgb);
+    void setPixel(const QPoint &pt, uint index_or_rgb);
+    QVector<QRgb> colorTable() const;
+    void setColorTable(const QVector<QRgb> colors);
+    void fill(uint pixel);
+    void fill(const QColor &color);
+    void fill(Qt::GlobalColor color);
+    bool hasAlphaChannel() const;
+    void setAlphaChannel(const QImage &alphaChannel);
+    QImage alphaChannel() const;
+    QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const;
+    QImage createHeuristicMask(bool clipTight = true) const;
+    QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const;
+    inline QImage scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                        Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QImage scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                 Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage transformed(const QMatrix &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &, int w, int h);
+    QImage transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &, int w, int h);
+    QImage mirrored(bool horizontally = false, bool vertically = true) const;
+    QImage rgbSwapped() const;
+    void invertPixels(InvertMode = InvertRgb);
+    bool load(QIODevice *device, const char* format);
+    bool load(const QString &fileName, const char* format=0);
+    bool loadFromData(const uchar *buf, int len, const char *format = 0);
+    inline bool loadFromData(const QByteArray &data, const char* aformat=0)
+        { return loadFromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), aformat); }
+    bool save(const QString &fileName, const char* format=0, int quality=-1) const;
+    bool save(QIODevice *device, const char* format=0, int quality=-1) const;
+    static QImage fromData(const uchar *data, int size, const char *format = 0);
+    inline static QImage fromData(const QByteArray &data, const char *format = 0)
+        { return fromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), format); }
+    int serialNumber() const;
+    qint64 cacheKey() const;
+    QPaintEngine *paintEngine() const;
+    int dotsPerMeterX() const;
+    int dotsPerMeterY() const;
+    void setDotsPerMeterX(int);
+    void setDotsPerMeterY(int);
+    QPoint offset() const;
+    void setOffset(const QPoint&);
+    QStringList textKeys() const;
+    QString text(const QString &key = QString()) const;
+    void setText(const QString &key, const QString &value);
+    QString text(const char* key, const char* lang=0) const;
+    QList<QImageTextKeyLang> textList() const;
+    QStringList textLanguages() const;
+    QString text(const QImageTextKeyLang&) const;
+    void setText(const char* key, const char* lang, const QString&);
+protected:
+    virtual int metric(PaintDeviceMetric metric) const;
+private:
+    friend class QWSOnScreenSurface;
+    QImageData *d;
+    friend class QRasterPixmapData;
+    friend class QBlittablePixmapData;
+    friend class QPixmapCacheEntry;
+    friend qint64 qt_image_id(const QImage &image);
+    friend const QVector<QRgb> *qt_image_colortable(const QImage &image);
+public:
+    typedef QImageData * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+template <> inline bool qIsDetached<QImage>(QImage &t) { return t.isDetached(); } template <> inline void qSwap<QImage>(QImage &value1, QImage &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QImage>(::QImage &value1, ::QImage &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+template<> class QTypeInfo<QImage > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QImage)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QImage"; } };
+ inline bool QImage::valid(const QPoint &pt) const { return valid(pt.x(), pt.y()); }
+ inline int QImage::pixelIndex(const QPoint &pt) const { return pixelIndex(pt.x(), pt.y());}
+ inline QRgb QImage::pixel(const QPoint &pt) const { return pixel(pt.x(), pt.y()); }
+ inline void QImage::setPixel(const QPoint &pt, uint index_or_rgb) { setPixel(pt.x(), pt.y(), index_or_rgb); }
+ QDataStream &operator<<(QDataStream &, const QImage &);
+ QDataStream &operator>>(QDataStream &, QImage &);
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QImageWriter;
+class QImageReader;
+class QColor;
+class QVariant;
+class QX11Info;
+class QPixmapData;
+class QPixmap : public QPaintDevice
+{
+public:
+    QPixmap();
+    explicit QPixmap(QPixmapData *data);
+    QPixmap(int w, int h);
+    QPixmap(const QSize &);
+    QPixmap(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    QPixmap(const char * const xpm[]);
+    QPixmap(const QPixmap &);
+    ~QPixmap();
+    QPixmap &operator=(const QPixmap &);
+    inline void swap(QPixmap &other) { qSwap(data, other.data); }
+    operator QVariant() const;
+    bool isNull() const;
+    int devType() const;
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+    int depth() const;
+    static int defaultDepth();
+    void fill(const QColor &fillColor = Qt::white);
+    void fill(const QWidget *widget, const QPoint &ofs);
+    inline void fill(const QWidget *widget, int xofs, int yofs) { fill(widget, QPoint(xofs, yofs)); }
+    QBitmap mask() const;
+    void setMask(const QBitmap &);
+    QPixmap alphaChannel() const;
+    void setAlphaChannel(const QPixmap &);
+    bool hasAlpha() const;
+    bool hasAlphaChannel() const;
+    QBitmap createHeuristicMask(bool clipTight = true) const;
+    QBitmap createMaskFromColor(const QColor &maskColor) const;
+    QBitmap createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const;
+    static QPixmap grabWindow(WId, int x=0, int y=0, int w=-1, int h=-1);
+    static QPixmap grabWidget(QWidget *widget, const QRect &rect);
+    static inline QPixmap grabWidget(QWidget *widget, int x=0, int y=0, int w=-1, int h=-1)
+    { return grabWidget(widget, QRect(x, y, w, h)); }
+    inline QPixmap scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                          Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QPixmap scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                   Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap transformed(const QMatrix &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &m, int w, int h);
+    QPixmap transformed(const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &m, int w, int h);
+    QImage toImage() const;
+    static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    static QPixmap fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool load(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool loadFromData(const uchar *buf, uint len, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline bool loadFromData(const QByteArray &data, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool save(const QString& fileName, const char* format = 0, int quality = -1) const;
+    bool save(QIODevice* device, const char* format = 0, int quality = -1) const;
+    bool convertFromImage(const QImage &img, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline QPixmap copy(int x, int y, int width, int height) const;
+    QPixmap copy(const QRect &rect = QRect()) const;
+    inline void scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = 0);
+    void scroll(int dx, int dy, const QRect &rect, QRegion *exposed = 0);
+    int serialNumber() const;
+    qint64 cacheKey() const;
+    bool isDetached() const;
+    void detach();
+    bool isQBitmap() const;
+    enum ShareMode { ImplicitlyShared, ExplicitlyShared };
+    static QPixmap fromX11Pixmap(Qt::HANDLE pixmap, ShareMode mode = ImplicitlyShared);
+    static int x11SetDefaultScreen(int screen);
+    void x11SetScreen(int screen);
+    const QX11Info &x11Info() const;
+    Qt::HANDLE x11PictureHandle() const;
+    Qt::HANDLE handle() const;
+    QPaintEngine *paintEngine() const;
+    inline bool operator!() const { return isNull(); }
+protected:
+    int metric(PaintDeviceMetric) const;
+private:
+    QExplicitlySharedDataPointer<QPixmapData> data;
+    bool doImageIO(QImageWriter *io, int quality) const;
+    enum Type { PixmapType, BitmapType };
+    QPixmap(const QSize &s, Type);
+    void init(int, int, Type = PixmapType);
+    QPixmap(const QSize &s, int type);
+    void init(int, int, int);
+    void deref();
+    friend class QPixmapData;
+    friend class QX11PixmapData;
+    friend class QMacPixmapData;
+    friend class QSymbianRasterPixmapData;
+    friend class QBitmap;
+    friend class QPaintDevice;
+    friend class QPainter;
+    friend class QGLWidget;
+    friend class QX11PaintEngine;
+    friend class QCoreGraphicsPaintEngine;
+    friend class QWidgetPrivate;
+    friend class QRasterBuffer;
+    friend QDataStream &operator>>(QDataStream &, QPixmap &);
+    friend qint64 qt_pixmap_id(const QPixmap &pixmap);
+public:
+    QPixmapData* pixmapData() const;
+public:
+    typedef QExplicitlySharedDataPointer<QPixmapData> DataPtr;
+    inline DataPtr &data_ptr() { return data; }
+};
+template <> inline bool qIsDetached<QPixmap>(QPixmap &t) { return t.isDetached(); } template <> inline void qSwap<QPixmap>(QPixmap &value1, QPixmap &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QPixmap>(::QPixmap &value1, ::QPixmap &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const
+{
+    return copy(QRect(ax, ay, awidth, aheight));
+}
+inline void QPixmap::scroll(int dx, int dy, int ax, int ay, int awidth, int aheight, QRegion *exposed)
+{
+    scroll(dx, dy, QRect(ax, ay, awidth, aheight), exposed);
+}
+inline bool QPixmap::loadFromData(const QByteArray &buf, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    return loadFromData(reinterpret_cast<const uchar *>(buf.constData()), buf.size(), format, flags);
+}
+ QDataStream &operator<<(QDataStream &, const QPixmap &);
+ QDataStream &operator>>(QDataStream &, QPixmap &);
+typedef QtValidLicenseForGuiModule QtGuiModule;
+class QIconPrivate;
+class QIconEngine;
+class QIconEngineV2;
+class QIcon
+{
+public:
+    enum Mode { Normal, Disabled, Active, Selected };
+    enum State { On, Off };
+    QIcon();
+    QIcon(const QPixmap &pixmap);
+    QIcon(const QIcon &other);
+    explicit QIcon(const QString &fileName);
+    explicit QIcon(QIconEngine *engine);
+    explicit QIcon(QIconEngineV2 *engine);
+    ~QIcon();
+    QIcon &operator=(const QIcon &other);
+    inline void swap(QIcon &other) { qSwap(d, other.d); }
+    operator QVariant() const;
+    QPixmap pixmap(const QSize &size, Mode mode = Normal, State state = Off) const;
+    inline QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(w, h), mode, state); }
+    inline QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(extent, extent), mode, state); }
+    QSize actualSize(const QSize &size, Mode mode = Normal, State state = Off) const;
+    QString name() const;
+    void paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const;
+    inline void paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const
+        { paint(painter, QRect(x, y, w, h), alignment, mode, state); }
+    bool isNull() const;
+    bool isDetached() const;
+    void detach();
+    int serialNumber() const;
+    qint64 cacheKey() const;
+    void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);
+    void addFile(const QString &fileName, const QSize &size = QSize(), Mode mode = Normal, State state = Off);
+    QList<QSize> availableSizes(Mode mode = Normal, State state = Off) const;
+    static QIcon fromTheme(const QString &name, const QIcon &fallback = QIcon());
+    static bool hasThemeIcon(const QString &name);
+    static QStringList themeSearchPaths();
+    static void setThemeSearchPaths(const QStringList &searchpath);
+    static QString themeName();
+    static void setThemeName(const QString &path);
+private:
+    QIconPrivate *d;
+    friend QDataStream &operator<<(QDataStream &, const QIcon &);
+    friend QDataStream &operator>>(QDataStream &, QIcon &);
+public:
+    typedef QIconPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+template <> inline bool qIsDetached<QIcon>(QIcon &t) { return t.isDetached(); } template <> inline void qSwap<QIcon>(QIcon &value1, QIcon &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QIcon>(::QIcon &value1, ::QIcon &value2) { swap(value1.data_ptr(), value2.data_ptr()); } }
+template<> class QTypeInfo<QIcon > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QIcon)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QIcon"; } };
+ QDataStream &operator<<(QDataStream &, const QIcon &);
+ QDataStream &operator>>(QDataStream &, QIcon &);
+class KIconLoader;
+class QStringList;
+class __attribute__ ((visibility("default"))) KIcon : public QIcon
+{
+public:
+    explicit KIcon(const QString& iconName, KIconLoader* iconLoader,
+                   const QStringList& overlays);
+    explicit KIcon(const QString& iconName, KIconLoader* iconLoader);
+    explicit KIcon(const QString& iconName);
+    explicit KIcon(const QIcon& copy);
+    KIcon();
+    ~KIcon();
+    KIcon& operator=( const KIcon &other );
+private:
+    class Private;
+    Private* const d;
+};
+class Data;
+class DataTypePrivate;
+class DataStructure;
+class Document;
+class __attribute__ ((visibility("default"))) DataType : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    static DataTypePtr create(Document* document, int identifier);
+    virtual ~DataType();
+    QString name() const;
+    QString iconName() const;
+    KIcon icon() const;
+    int identifier() const;
+    QColor defaultColor() const;
+    void addProperty(const QString& name, const QString& defaultValue = QString());
+    void removeProperty(const QString& name);
+    void renameProperty(const QString& oldName, const QString& newName);
+    QStringList properties() const;
+    void setPropertyDefaultValue(const QString& name, const QVariant& value);
+    QVariant propertyDefaultValue(const QString& name) const;
+    void setPropertyVisible(const QString& name, bool visible);
+    bool isPropertyVisible(const QString& name) const;
+public :
+    void setName(const QString& name);
+    void setIcon(const QString& icon);
+    void setDefaultColor(const QColor& color);
+    void remove();
+protected:
+    void removed();
+    void defaultColorChanged(const QColor& color);
+    void iconChanged(const QString& icon);
+    void nameChanged(const QString& name);
+    void propertyAdded(const QString& name, const QVariant& defaultValue);
+    void propertyRemoved(const QString& name);
+    void propertyDefaultValueChanged(const QString& name);
+    void propertyVisibilityChanged(const QString& name);
+    void propertyRenamed(const QString& oldName, const QString& newName);
+protected:
+    DataType(Document* document, int identifier);
+private:
+    boost::scoped_ptr<DataTypePrivate> d;
+    DataType(const DataType &);
+    DataType& operator=(const DataType&);
+};
+class DataItem;
+class Pointer;
+class DataPrivate;
+class __attribute__ ((visibility("default"))) Data : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    static DataPtr create(DataStructurePtr dataStructure, int uniqueIdentifier, int dataType);
+    virtual DataPtr getData() const;
+    virtual ~Data();
+    PointerPtr addPointer(DataPtr to);
+    void registerInPointer(PointerPtr e);
+    void registerOutPointer(PointerPtr e);
+    void remove(PointerPtr e);
+    DataStructurePtr dataStructure() const;
+    QScriptValue scriptValue() const;
+    virtual void setEngine(QScriptEngine *_engine);
+    qreal x() const;
+    qreal y() const;
+    qreal width() const;
+    QVariant color() const;
+    QString icon() const;
+    QList<QString> properties() const;
+    bool isVisible() const;
+    int identifier() const;
+    int dataType() const;
+    DataList adjacentDataList() const;
+    PointerList pointerList() const;
+    PointerList pointerList(DataPtr to) const;
+    PointerList& inPointerList() const;
+    PointerList& outPointerList() const;
+public :
+    void remove();
+    void self_remove();
+    void setX(int x);
+    void setY(int y);
+    void setWidth(double w);
+    void setPos(qreal x, qreal y);
+    void setColor(const QVariant& s);
+    void setVisible(bool visible);
+    void setDataType(int dataType);
+    void addDynamicProperty(const QString &property, const QVariant& value);
+    void removeDynamicProperty(const QString &property);
+    void updateDynamicProperty(const QString &property);
+    void renameDynamicProperty(const QString &oldName, const QString &newName);
+    void updatePointerList();
+    QScriptValue type();
+    QScriptValue set_type(int type);
+    void add_property(const QString &name, const QString& value);
+    void remove_property(const QString &name);
+    QScriptValue adj_data();
+    QScriptValue adj_pointers();
+    QScriptValue adj_pointers(int pointerType);
+    QScriptValue input_pointers();
+    QScriptValue output_pointers();
+    QScriptValue output_pointers(int pointerType);
+    QScriptValue connected_pointers(Data *n);
+protected:
+    void removed();
+    void posChanged(QPointF p);
+    void widthChanged(double w);
+    void colorChanged(QColor c);
+    void visibilityChanged(bool visible);
+    void useColorChanged(bool b);
+    void dataTypeChanged(int dataType);
+    void pointerListChanged();
+    void propertyAdded(const QString &name);
+    void propertyRemoved(const QString &name);
+    void propertyChanged(const QString &name);
+protected:
+    Data(DataStructurePtr dataStructure, int uniqueIdentifer, int dataType);
+    template<typename T>
+    static DataPtr create(DataStructurePtr parent, int uniqueIdentifier, int dataType) {
+        DataPtr pi(new T(parent, uniqueIdentifier, dataType));
+        pi->setQpointer(pi);
+        pi->initialize();
+        return pi;
+    }
+    bool eventFilter(QObject *obj, QEvent *event);
+private:
+    const boost::scoped_ptr<DataPrivate> d;
+    void setQpointer(DataPtr q);
+    void initialize();
+    Data(const Data&);
+    Data& operator=(const Data&);
+};
+class Data;
+class PointerTypePrivate;
+class DataStructure;
+class Document;
+class __attribute__ ((visibility("default"))) PointerType : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    enum Direction {
+        Unidirectional,
+        Bidirectional
+    };
+    static PointerTypePtr create(Document* document, int identifier);
+    virtual ~PointerType();
+    QString name() const;
+    int identifier() const;
+    Direction direction() const;
+    Qt::PenStyle lineStyle() const;
+    QColor defaultColor() const;
+    void addProperty(const QString& name, const QString& defaultValue = "");
+    void removeProperty(const QString& name);
+    void renameProperty(const QString& oldName, const QString& newName);
+    QStringList properties() const;
+    void setPropertyDefaultValue(const QString& name, const QVariant& value);
+    QVariant propertyDefaultValue(const QString& name) const;
+    void setPropertyVisible(const QString& name, bool visible);
+    bool isPropertyVisible(const QString& name) const;
+public :
+    void setName(const QString& name);
+    void setDefaultColor(const QColor& color);
+    void setDirection(PointerType::Direction direction);
+    void setLineStyle(Qt::PenStyle lineStyle);
+    void remove();
+protected:
+    void removed();
+    void styleChanged();
+    void directionChanged(PointerType::Direction direction);
+    void nameChanged(const QString& name);
+    void propertyAdded(const QString& name, const QVariant& defaultValue);
+    void propertyRemoved(const QString& name);
+    void propertyDefaultValueChanged(const QString& name);
+    void propertyVisibilityChanged(const QString& name);
+    void propertyRenamed(const QString& oldName, const QString& newName);
+protected:
+    PointerType(Document* document, int identifier);
+private:
+    boost::scoped_ptr<PointerTypePrivate> d;
+    PointerType(const PointerType &);
+    PointerType & operator=(const PointerType &);
+};
+class Data;
+class PointerPrivate;
+class DataStructure;
+class QtScriptBackend;
+class __attribute__ ((visibility("default"))) Pointer : public QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+public:
+    static PointerPtr create(DataStructurePtr dataStructure, DataPtr from, DataPtr to, int pointerType);
+    PointerPtr getPointer() const;
+    virtual ~Pointer();
+    PointerType::Direction direction() const;
+    DataStructurePtr dataStructure() const;
+    int relativeIndex() const;
+    QScriptValue scriptValue() const;
+    void setEngine(QScriptEngine *engine);
+protected:
+    void removed();
+    void changed();
+    void posChanged();
+    void pointerTypeChanged(int pointerType);
+    void directionChanged(PointerType::Direction direction);
+    void propertyAdded(QString name);
+    void propertyRemoved(QString name);
+    void propertyChanged(QString name);
+public :
+    DataPtr from() const;
+    DataPtr to() const;
+    void remove();
+    void self_remove();
+    void setPointerType(int pointerType);
+    QColor color() const;
+    void setColor(const QColor& color);
+    int pointerType() const;
+    qreal width() const;
+    void setWidth(qreal width);
+    Qt::PenStyle style() const;
+    void addDynamicProperty(const QString& property, const QVariant& value);
+    void removeDynamicProperty(const QString& property);
+    void updateDynamicProperty(const QString& property);
+    void renameDynamicProperty(const QString& oldName, const QString& newName);
+    void updateRelativeIndex();
+    QList<QString> properties() const;
+    bool isVisible() const;
+    void setVisible(bool visible);
+    QScriptValue type() const;
+    QScriptValue set_type(int type);
+    void add_property(const QString& name, const QString& value);
+    void remove_property(const QString& name);
+    QScriptValue start() const;
+    QScriptValue end() const;
+protected:
+    Pointer(DataStructurePtr parent, DataPtr from, DataPtr to, int pointerType = 0);
+    template<typename T>
+    static PointerPtr create(DataStructurePtr parent, DataPtr from, DataPtr to, int pointerType) {
+        PointerPtr pi(new T(parent, from, to, pointerType));
+        pi->setQpointer(pi);
+        pi->initialize();
+        return pi;
+    }
+    bool eventFilter(QObject *obj, QEvent *event);
+private:
+    const boost::scoped_ptr<PointerPrivate> d;
+    void setQpointer(PointerPtr q);
+    void initialize();
+    Pointer(const Pointer&);
+    Pointer& operator=(const Pointer&);
+};
+namespace DotParser
+{
+struct DotGraphParsingHelper {
+    typedef QMap<QString,QString> AttributesMap;
+    DotGraphParsingHelper();
+    void createData(QString identifier);
+    void createSubDataStructure();
+    void leaveSubDataStructure();
+    void setDataStructureAttributes();
+    void setSubDataStructureAttributes();
+    void setSubDataStructureId(QString identifier);
+    void setDataAttributes();
+    void setPointerAttributes();
+    void applyAttributedList();
+    void createPointers();
+    void addEdgeBound(QString bound) {
+        edgebounds.append(bound);
+    }
+    void setObjectAttributes(QObject *graphElement, const DotParser::DotGraphParsingHelper::AttributesMap &attributes);
+    QString attributeId;
+    QString valid;
+    std::string attributed;
+    AttributesMap unprocessedAttributes;
+    AttributesMap dataStructureAttributes;
+    AttributesMap dataAttributes;
+    AttributesMap pointerAttributes;
+    QList< AttributesMap > dataStructureAttributeStack;
+    QList< AttributesMap > dataAttributeStack;
+    QList< AttributesMap > pointerAttributeStack;
+    QStringList edgebounds;
+    boost::shared_ptr<Rocs::GraphStructure> dataStructure;
+    QList<GroupPtr> groupStack;
+    DataPtr currentDataPtr;
+    PointerPtr currentPointerPtr;
+    Document* gd;
+    QMap<QString, DataPtr> dataMap;
+};
+}
+__attribute__ ((visibility("default"))) QDebug kDebugStream(QtMsgType level, int area, const char *file = 0,
+                                   int line = -1, const char *funcinfo = 0);
+__attribute__ ((visibility("default"))) QDebug kDebugDevNull();
+__attribute__ ((visibility("default"))) QString kRealBacktrace(int);
+inline QString kBacktrace(int levels=-1) { return kRealBacktrace(levels); }
+__attribute__ ((visibility("default"))) void kClearDebugConfig();
+static inline QDebug kDebug(int area = 0)
+{ return kDebugStream(QtDebugMsg, area); }
+static inline QDebug kDebug(bool cond, int area = 0)
+{ return cond ? kDebug(area) : kDebugDevNull(); }
+static inline QDebug kWarning(int area = 0)
+{ return kDebugStream(QtWarningMsg, area); }
+static inline QDebug kWarning(bool cond, int area = 0)
+{ return cond ? kWarning(area) : kDebugDevNull(); }
+static inline QDebug kError(int area = 0)
+{ return kDebugStream(QtCriticalMsg, area); }
+static inline QDebug kError(bool cond, int area = 0)
+{ return cond ? kError(area) : kDebugDevNull(); }
+static inline QDebug kFatal(int area = 0)
+{ return kDebugStream(QtFatalMsg, area); }
+static inline QDebug kFatal(bool cond, int area = 0)
+{ return cond ? kFatal(area) : kDebugDevNull(); }
+struct KDebugTag { };
+typedef QDebug (*KDebugStreamFunction)(QDebug, KDebugTag);
+inline QDebug operator<<(QDebug s, KDebugStreamFunction f)
+{ return (*f)(s, KDebugTag()); }
+__attribute__ ((visibility("default"))) QDebug perror(QDebug, KDebugTag);
+class KUrl;
+class KDateTime;
+class QObject;
+__attribute__ ((visibility("default"))) QDebug operator<<(QDebug s, const KUrl &url);
+__attribute__ ((visibility("default"))) QDebug operator<<(QDebug s, const KDateTime &time);
+class kndbgstream { };
+typedef QDebug kdbgstream;
+static inline QDebug kdDebug(int area = 0) { return kDebug(area); }
+static inline QDebug kdWarning(int area = 0) { return kWarning(area); }
+static inline QDebug kdError(int area = 0) { return kError(area); }
+static inline QDebug kdFatal(int area = 0) { return kFatal(area); }
+inline QString kdBacktrace(int levels=-1) { return kBacktrace( levels ); }
+static inline QDebug kndDebug() { return kDebugDevNull(); }
+class WrongSyntax {};
+class KDebug
+{
+    const char *file;
+    const char *funcinfo;
+    int line;
+    QtMsgType level;
+public:
+    class Block;
+    explicit inline KDebug(QtMsgType type, const char *f = 0, int l = -1, const char *info = 0)
+        : file(f), funcinfo(info), line(l), level(type)
+        {
+        }
+    inline QDebug operator()(int area = 0)
+        { return kDebugStream(level, area, file, line, funcinfo); }
+    inline QDebug operator()(bool cond, int area = 0)
+        { if (cond) return operator()(area); return kDebugDevNull(); }
+    static __attribute__ ((visibility("default"))) bool hasNullOutput(QtMsgType type,
+                                             bool condition,
+                                             int area,
+                                             bool enableByDefault);
+    static inline bool hasNullOutputQtDebugMsg(int area = 0)
+        { return hasNullOutput(QtDebugMsg, true, area, false); }
+    static inline bool hasNullOutputQtDebugMsg(bool condition, int area = 0)
+        { return hasNullOutput(QtDebugMsg, condition, area, false); }
+    static __attribute__ ((visibility("default"))) int registerArea(const QByteArray& areaName, bool enabled = true);
+private:
+    WrongSyntax operator()(const char*) {return WrongSyntax();}
+};
+class __attribute__ ((visibility("default"))) KDebug::Block
+{
+public:
+    Block(const char* label, int area = 0);
+    ~Block();
+private:
+    QElapsedTimer m_startTime;
+    const char *m_label;
+    int m_area;
+    int m_color;
+    class Private;
+    Private* d;
+};
+namespace boost
+{
+namespace detail
+{
+template<class T> struct addr_impl_ref
+{
+    T & v_;
+    inline addr_impl_ref( T & v ): v_( v ) {}
+    inline operator T& () const { return v_; }
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+template<class T> struct addressof_impl
+{
+    static inline T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+    static inline T * f( T * v, int )
+    {
+        return v;
+    }
+};
+}
+template<class T> T * addressof( T & v )
+{
+    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+}
+}
+namespace mpl_ { namespace aux {} }
+namespace boost { namespace mpl { using namespace mpl_;
+namespace aux { using namespace mpl_::aux; }
+}}
+namespace mpl_ {
+template< bool C_ > struct bool_;
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+}
+namespace boost { namespace mpl { using ::mpl_::bool_; } }
+namespace boost { namespace mpl { using ::mpl_::true_; } }
+namespace boost { namespace mpl { using ::mpl_::false_; } }
+namespace mpl_ {
+struct integral_c_tag { static const int value = 0; };
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
+namespace mpl_ {
+template< bool C_ > struct bool_
+{
+    static const bool value = C_;
+    typedef integral_c_tag tag;
+    typedef bool_ type;
+    typedef bool value_type;
+    operator bool() const { return this->value; }
+};
+template< bool C_ >
+bool const bool_<C_>::value;
+}
+namespace boost
+{
+template<class T> class reference_wrapper
+{
+public:
+    typedef T type;
+    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+    operator T& () const { return *t_; }
+    T& get() const { return *t_; }
+    T* get_pointer() const { return t_; }
+private:
+    T* t_;
+};
+template<class T> inline reference_wrapper<T> const ref(T & t)
+{
+    return reference_wrapper<T>(t);
+}
+template<class T> inline reference_wrapper<T const> const cref(T const & t)
+{
+    return reference_wrapper<T const>(t);
+}
+template<typename T>
+class is_reference_wrapper
+    : public mpl::false_
+{
+};
+template<typename T>
+class unwrap_reference
+{
+ public:
+    typedef T type;
+};
+template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };
+template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
+template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
+template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };
+template <class T> inline typename unwrap_reference<T>::type&
+unwrap_ref(T& t)
+{
+    return t;
+}
+template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+}
+namespace mpl_ {
+template< long N > struct long_;
+}
+namespace boost { namespace mpl { using ::mpl_::long_; } }
+namespace mpl_ {
+template< long N >
+struct long_
+{
+    static const long value = N;
+    typedef long_ type;
+    typedef long value_type;
+    typedef integral_c_tag tag;
+    typedef mpl_::long_< static_cast<long>((value + 1)) > next;
+    typedef mpl_::long_< static_cast<long>((value - 1)) > prior;
+    operator long() const { return static_cast<long>(this->value); }
+};
+template< long N >
+long const mpl_::long_< N >::value;
+}
+namespace boost {
+namespace detail {
+template <typename T> struct cv_traits_imp {};
+template <typename T>
+struct cv_traits_imp<T*>
+{
+    static const bool is_const = false;
+    static const bool is_volatile = false;
+    typedef T unqualified_type;
+};
+template <typename T>
+struct cv_traits_imp<const T*>
+{
+    static const bool is_const = true;
+    static const bool is_volatile = false;
+    typedef T unqualified_type;
+};
+template <typename T>
+struct cv_traits_imp<volatile T*>
+{
+    static const bool is_const = false;
+    static const bool is_volatile = true;
+    typedef T unqualified_type;
+};
+template <typename T>
+struct cv_traits_imp<const volatile T*>
+{
+    static const bool is_const = true;
+    static const bool is_volatile = true;
+    typedef T unqualified_type;
+};
+}
+}
+namespace mpl_ {
+template< int N > struct int_;
+}
+namespace boost { namespace mpl { using ::mpl_::int_; } }
+namespace mpl_ {
+template< int N >
+struct int_
+{
+    static const int value = N;
+    typedef int_ type;
+    typedef int value_type;
+    typedef integral_c_tag tag;
+    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
+    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
+    operator int() const { return static_cast<int>(this->value); }
+};
+template< int N >
+int const mpl_::int_< N >::value;
+}
+namespace boost { namespace mpl { namespace aux {
+template< typename F > struct template_arity;
+}}}
+namespace mpl_ {
+template< typename T, T N > struct integral_c;
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c; } }
+namespace mpl_ {
+template< typename T, T N >
+struct integral_c
+{
+    static const T value = N;
+    typedef integral_c type;
+    typedef T value_type;
+    typedef integral_c_tag tag;
+    typedef integral_c< T, static_cast<T>((value + 1)) > next;
+    typedef integral_c< T, static_cast<T>((value - 1)) > prior;
+    operator T() const { return static_cast<T>(this->value); }
+};
+template< typename T, T N >
+T const integral_c< T, N >::value;
+}
+namespace mpl_ {
+template< bool C >
+struct integral_c<bool, C>
+{
+    static const bool value = C;
+    typedef integral_c_tag tag;
+    typedef integral_c type;
+    typedef bool value_type;
+    operator bool() const { return this->value; }
+};
+}
+namespace boost{
+template <class T, T val>
+struct integral_constant : public mpl::integral_c<T, val>
+{
+   typedef integral_constant<T,val> type;
+};
+template<> struct integral_constant<bool,true> : public mpl::true_
+{
+   typedef integral_constant<bool,true> type;
+};
+template<> struct integral_constant<bool,false> : public mpl::false_
+{
+   typedef integral_constant<bool,false> type;
+};
+typedef integral_constant<bool,true> true_type;
+typedef integral_constant<bool,false> false_type;
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct is_volatile_rval_filter
+{
+   static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;
+};
+}
+template< typename T > struct is_volatile : public ::boost::integral_constant<bool,::boost::detail::is_volatile_rval_filter<T>::value> { public: };
+template< typename T > struct is_volatile< T& > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T, bool is_vol>
+struct remove_const_helper
+{
+    typedef T type;
+};
+template <typename T>
+struct remove_const_helper<T, true>
+{
+    typedef T volatile type;
+};
+template <typename T>
+struct remove_const_impl
+{
+    typedef typename remove_const_helper<
+          typename cv_traits_imp<T*>::unqualified_type
+        , ::boost::is_volatile<T>::value
+        >::type type;
+};
+}
+template< typename T > struct remove_const { public: typedef typename boost::detail::remove_const_impl<T>::type type; };
+template< typename T > struct remove_const<T&> { public: typedef T& type; };
+template< typename T, std::size_t N > struct remove_const<T const[N]> { public: typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { public: typedef T volatile type[N]; };
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct remove_rvalue_ref
+{
+   typedef T type;
+};
+}
+template< typename T > struct remove_reference { public: typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
+template< typename T > struct remove_reference<T&> { public: typedef T type; };
+}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        typedef char yes_type;
+        typedef char (&no_type)[2];
+        template<int N>
+        struct sized_type
+        {
+            typedef char (&type)[N];
+        };
+        struct dont_care;
+        struct undefined;
+        struct not_a_valid_type;
+        struct private_type_
+        {
+            private_type_ operator ,(int) const;
+        };
+        template<typename T>
+        struct uncvref
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct uncvref<T const>
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct uncvref<T &>
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct uncvref<T const &>
+        {
+            typedef T type;
+        };
+        template<typename T, std::size_t N>
+        struct uncvref<T const[N]>
+        {
+            typedef T type[N];
+        };
+        template<typename T, std::size_t N>
+        struct uncvref<T (&)[N]>
+        {
+            typedef T type[N];
+        };
+        template<typename T, std::size_t N>
+        struct uncvref<T const (&)[N]>
+        {
+            typedef T type[N];
+        };
+        struct ignore
+        {
+            ignore()
+            {}
+            template<typename T>
+            ignore(T const &)
+            {}
+        };
+        struct _default;
+        struct not_a_domain;
+        struct not_a_grammar;
+        struct not_a_generator;
+        template<typename T, typename Void = void>
+        struct is_transform_;
+        template<typename T, typename Void = void>
+        struct is_aggregate_;
+    }
+    typedef detail::ignore const ignore;
+    namespace argsns_
+    {
+        template<typename Arg0>
+        struct term;
+        template< typename Arg0> struct list1; template< typename Arg0 , typename Arg1> struct list2; template< typename Arg0 , typename Arg1 , typename Arg2> struct list3; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3> struct list4; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4> struct list5; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5> struct list6; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6> struct list7; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7> struct list8; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8> struct list9; template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9> struct list10;
+    }
+    using namespace argsns_;
+    namespace tagns_
+    {
+        namespace tag
+        {
+            struct terminal;
+            struct unary_plus;
+            struct negate;
+            struct dereference;
+            struct complement;
+            struct address_of;
+            struct logical_not;
+            struct pre_inc;
+            struct pre_dec;
+            struct post_inc;
+            struct post_dec;
+            struct shift_left;
+            struct shift_right;
+            struct multiplies;
+            struct divides;
+            struct modulus;
+            struct plus;
+            struct minus;
+            struct less;
+            struct greater;
+            struct less_equal;
+            struct greater_equal;
+            struct equal_to;
+            struct not_equal_to;
+            struct logical_or;
+            struct logical_and;
+            struct bitwise_and;
+            struct bitwise_or;
+            struct bitwise_xor;
+            struct comma;
+            struct mem_ptr;
+            struct assign;
+            struct shift_left_assign;
+            struct shift_right_assign;
+            struct multiplies_assign;
+            struct divides_assign;
+            struct modulus_assign;
+            struct plus_assign;
+            struct minus_assign;
+            struct bitwise_and_assign;
+            struct bitwise_or_assign;
+            struct bitwise_xor_assign;
+            struct subscript;
+            struct member;
+            struct if_else_;
+            struct function;
+            struct proto_expr;
+            struct proto_expr_iterator;
+            struct proto_flat_view;
+        }
+    }
+    using namespace tagns_;
+    template<typename Expr>
+    struct tag_of;
+    struct _;
+    struct default_generator;
+    struct basic_default_generator;
+    template<template<typename> class Extends>
+    struct generator;
+    template<template<typename> class Extends>
+    struct pod_generator;
+    struct by_value_generator;
+    template<typename First, typename Second>
+    struct compose_generators;
+    template<typename Generator, typename Void = void>
+    struct wants_basic_expr;
+    template<typename Generator>
+    struct use_basic_expr;
+    namespace domainns_
+    {
+        typedef detail::not_a_domain no_super_domain;
+        template<
+            typename Generator = default_generator
+          , typename Grammar = proto::_
+          , typename Super = no_super_domain
+        >
+        struct domain;
+        struct default_domain;
+        struct basic_default_domain;
+        struct deduce_domain;
+        template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr = wants_basic_expr<typename Domain::proto_generator>::value>
+        struct base_expr;
+    }
+    using namespace domainns_;
+    namespace exprns_
+    {
+        template<typename Tag, typename Args, long Arity = Args::arity>
+        struct basic_expr;
+        template<typename Tag, typename Args, long Arity = Args::arity>
+        struct expr;
+        template<
+            typename Expr
+          , typename Derived
+          , typename Domain = default_domain
+          , long Arity = Expr::proto_arity_c
+        >
+        struct extends;
+        template<typename This, typename Fun, typename Domain>
+        struct virtual_member;
+        struct is_proto_expr;
+    }
+    using exprns_::expr;
+    using exprns_::basic_expr;
+    using exprns_::extends;
+    using exprns_::is_proto_expr;
+    template< typename G0 = void , typename G1 = void , typename G2 = void , typename G3 = void , typename G4 = void , typename G5 = void , typename G6 = void , typename G7 = void , typename G8 = void , typename G9 = void >
+    struct or_;
+    template< typename G0 = void , typename G1 = void , typename G2 = void , typename G3 = void , typename G4 = void , typename G5 = void , typename G6 = void , typename G7 = void , typename G8 = void , typename G9 = void >
+    struct and_;
+    template<typename Grammar>
+    struct not_;
+    template<typename Condition, typename Then = _, typename Else = not_<_> >
+    struct if_;
+    template<typename Cases, typename Transform = tag_of<_>()>
+    struct switch_;
+    template<typename T>
+    struct exact;
+    template<typename T>
+    struct convertible_to;
+    template<typename Grammar>
+    struct vararg;
+    int const N = (2147483647 >> 10);
+    namespace context
+    {
+        struct null_context;
+        template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
+        struct null_eval;
+        struct default_context;
+        template<typename Expr, typename Context, typename Tag = typename Expr::proto_tag, long Arity = Expr::proto_arity_c>
+        struct default_eval;
+        template<typename Derived, typename DefaultCtx = default_context>
+        struct callable_context;
+        template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
+        struct callable_eval;
+    }
+    using context::null_context;
+    using context::null_eval;
+    using context::default_context;
+    using context::default_eval;
+    using context::callable_context;
+    using context::callable_eval;
+    namespace utility
+    {
+        template<typename T, typename Domain = default_domain>
+        struct literal;
+    }
+    using utility::literal;
+    namespace result_of
+    {
+        template<typename T, typename Domain = default_domain>
+        struct as_expr;
+        template<typename T, typename Domain = default_domain>
+        struct as_child;
+        template<typename Expr, typename N = mpl::long_<0> >
+        struct child;
+        template<typename Expr, long N>
+        struct child_c;
+        template<typename Expr>
+        struct left;
+        template<typename Expr>
+        struct right;
+        template<typename Expr>
+        struct deep_copy;
+        template<typename Expr, typename Context>
+        struct eval;
+        template<
+            typename Tag
+          , typename DomainOrA0
+ , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
+          , typename Void = void
+        >
+        struct make_expr;
+        template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void>
+        struct unpack_expr;
+    }
+    template<typename T, typename Void = void>
+    struct is_expr;
+    template<typename T, typename Void = void>
+    struct is_domain;
+    template<typename SubDomain, typename SuperDomain>
+    struct is_sub_domain_of;
+    template<typename Expr>
+    struct arity_of;
+    template<typename T, typename Void = void>
+    struct domain_of;
+    template<typename Expr, typename Grammar>
+    struct matches;
+    template<typename Tag, typename Arg>
+    struct unary_expr;
+    template<typename Tag, typename Left, typename Right>
+    struct binary_expr;
+    template<typename Tag, typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void >
+    struct nary_expr;
+    template<typename T> struct terminal;
+    template<typename T> struct unary_plus;
+    template<typename T> struct negate;
+    template<typename T> struct dereference;
+    template<typename T> struct complement;
+    template<typename T> struct address_of;
+    template<typename T> struct logical_not;
+    template<typename T> struct pre_inc;
+    template<typename T> struct pre_dec;
+    template<typename T> struct post_inc;
+    template<typename T> struct post_dec;
+    template<typename T, typename U> struct shift_left;
+    template<typename T, typename U> struct shift_right;
+    template<typename T, typename U> struct multiplies;
+    template<typename T, typename U> struct divides;
+    template<typename T, typename U> struct modulus;
+    template<typename T, typename U> struct plus;
+    template<typename T, typename U> struct minus;
+    template<typename T, typename U> struct less;
+    template<typename T, typename U> struct greater;
+    template<typename T, typename U> struct less_equal;
+    template<typename T, typename U> struct greater_equal;
+    template<typename T, typename U> struct equal_to;
+    template<typename T, typename U> struct not_equal_to;
+    template<typename T, typename U> struct logical_or;
+    template<typename T, typename U> struct logical_and;
+    template<typename T, typename U> struct bitwise_and;
+    template<typename T, typename U> struct bitwise_or;
+    template<typename T, typename U> struct bitwise_xor;
+    template<typename T, typename U> struct comma;
+    template<typename T, typename U> struct mem_ptr;
+    template<typename T, typename U> struct assign;
+    template<typename T, typename U> struct shift_left_assign;
+    template<typename T, typename U> struct shift_right_assign;
+    template<typename T, typename U> struct multiplies_assign;
+    template<typename T, typename U> struct divides_assign;
+    template<typename T, typename U> struct modulus_assign;
+    template<typename T, typename U> struct plus_assign;
+    template<typename T, typename U> struct minus_assign;
+    template<typename T, typename U> struct bitwise_and_assign;
+    template<typename T, typename U> struct bitwise_or_assign;
+    template<typename T, typename U> struct bitwise_xor_assign;
+    template<typename T, typename U> struct subscript;
+    template<typename T, typename U> struct member;
+    template<typename T, typename U, typename V> struct if_else_;
+    template< typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void >
+    struct function;
+    namespace functional
+    {
+        struct left;
+        struct right;
+        struct eval;
+        struct deep_copy;
+        template<typename Domain = default_domain>
+        struct as_expr;
+        template<typename Domain = default_domain>
+        struct as_child;
+        template<typename N = mpl::long_<0> >
+        struct child;
+        template<long N>
+        struct child_c;
+        template<typename Tag, typename Domain = deduce_domain>
+        struct make_expr;
+        template<typename Tag, typename Domain = deduce_domain>
+        struct unpack_expr;
+        typedef make_expr<tag::terminal> make_terminal;
+        typedef make_expr<tag::unary_plus> make_unary_plus;
+        typedef make_expr<tag::negate> make_negate;
+        typedef make_expr<tag::dereference> make_dereference;
+        typedef make_expr<tag::complement> make_complement;
+        typedef make_expr<tag::address_of> make_address_of;
+        typedef make_expr<tag::logical_not> make_logical_not;
+        typedef make_expr<tag::pre_inc> make_pre_inc;
+        typedef make_expr<tag::pre_dec> make_pre_dec;
+        typedef make_expr<tag::post_inc> make_post_inc;
+        typedef make_expr<tag::post_dec> make_post_dec;
+        typedef make_expr<tag::shift_left> make_shift_left;
+        typedef make_expr<tag::shift_right> make_shift_right;
+        typedef make_expr<tag::multiplies> make_multiplies;
+        typedef make_expr<tag::divides> make_divides;
+        typedef make_expr<tag::modulus> make_modulus;
+        typedef make_expr<tag::plus> make_plus;
+        typedef make_expr<tag::minus> make_minus;
+        typedef make_expr<tag::less> make_less;
+        typedef make_expr<tag::greater> make_greater;
+        typedef make_expr<tag::less_equal> make_less_equal;
+        typedef make_expr<tag::greater_equal> make_greater_equal;
+        typedef make_expr<tag::equal_to> make_equal_to;
+        typedef make_expr<tag::not_equal_to> make_not_equal_to;
+        typedef make_expr<tag::logical_or> make_logical_or;
+        typedef make_expr<tag::logical_and> make_logical_and;
+        typedef make_expr<tag::bitwise_and> make_bitwise_and;
+        typedef make_expr<tag::bitwise_or> make_bitwise_or;
+        typedef make_expr<tag::bitwise_xor> make_bitwise_xor;
+        typedef make_expr<tag::comma> make_comma;
+        typedef make_expr<tag::mem_ptr> make_mem_ptr;
+        typedef make_expr<tag::assign> make_assign;
+        typedef make_expr<tag::shift_left_assign> make_shift_left_assign;
+        typedef make_expr<tag::shift_right_assign> make_shift_right_assign;
+        typedef make_expr<tag::multiplies_assign> make_multiplies_assign;
+        typedef make_expr<tag::divides_assign> make_divides_assign;
+        typedef make_expr<tag::modulus_assign> make_modulus_assign;
+        typedef make_expr<tag::plus_assign> make_plus_assign;
+        typedef make_expr<tag::minus_assign> make_minus_assign;
+        typedef make_expr<tag::bitwise_and_assign> make_bitwise_and_assign;
+        typedef make_expr<tag::bitwise_or_assign> make_bitwise_or_assign;
+        typedef make_expr<tag::bitwise_xor_assign> make_bitwise_xor_assign;
+        typedef make_expr<tag::subscript> make_subscript;
+        typedef make_expr<tag::if_else_> make_if_else;
+        typedef make_expr<tag::function> make_function;
+        struct flatten;
+        struct make_pair;
+        struct first;
+        struct second;
+        struct at;
+        struct pop_front;
+        struct push_front;
+        struct pop_back;
+        struct push_back;
+        struct reverse;
+    }
+    typedef functional::flatten _flatten;
+    typedef functional::make_pair _make_pair;
+    typedef functional::first _first;
+    typedef functional::second _second;
+    typedef functional::pop_front _at;
+    typedef functional::pop_front _pop_front;
+    typedef functional::push_front _push_front;
+    typedef functional::pop_back _pop_back;
+    typedef functional::push_back _push_back;
+    typedef functional::reverse _reverse;
+    typedef functional::eval _eval;
+    struct _deep_copy;
+    typedef functional::make_expr<tag::terminal> _make_terminal;
+    typedef functional::make_expr<tag::unary_plus> _make_unary_plus;
+    typedef functional::make_expr<tag::negate> _make_negate;
+    typedef functional::make_expr<tag::dereference> _make_dereference;
+    typedef functional::make_expr<tag::complement> _make_complement;
+    typedef functional::make_expr<tag::address_of> _make_address_of;
+    typedef functional::make_expr<tag::logical_not> _make_logical_not;
+    typedef functional::make_expr<tag::pre_inc> _make_pre_inc;
+    typedef functional::make_expr<tag::pre_dec> _make_pre_dec;
+    typedef functional::make_expr<tag::post_inc> _make_post_inc;
+    typedef functional::make_expr<tag::post_dec> _make_post_dec;
+    typedef functional::make_expr<tag::shift_left> _make_shift_left;
+    typedef functional::make_expr<tag::shift_right> _make_shift_right;
+    typedef functional::make_expr<tag::multiplies> _make_multiplies;
+    typedef functional::make_expr<tag::divides> _make_divides;
+    typedef functional::make_expr<tag::modulus> _make_modulus;
+    typedef functional::make_expr<tag::plus> _make_plus;
+    typedef functional::make_expr<tag::minus> _make_minus;
+    typedef functional::make_expr<tag::less> _make_less;
+    typedef functional::make_expr<tag::greater> _make_greater;
+    typedef functional::make_expr<tag::less_equal> _make_less_equal;
+    typedef functional::make_expr<tag::greater_equal> _make_greater_equal;
+    typedef functional::make_expr<tag::equal_to> _make_equal_to;
+    typedef functional::make_expr<tag::not_equal_to> _make_not_equal_to;
+    typedef functional::make_expr<tag::logical_or> _make_logical_or;
+    typedef functional::make_expr<tag::logical_and> _make_logical_and;
+    typedef functional::make_expr<tag::bitwise_and> _make_bitwise_and;
+    typedef functional::make_expr<tag::bitwise_or> _make_bitwise_or;
+    typedef functional::make_expr<tag::bitwise_xor> _make_bitwise_xor;
+    typedef functional::make_expr<tag::comma> _make_comma;
+    typedef functional::make_expr<tag::mem_ptr> _make_mem_ptr;
+    typedef functional::make_expr<tag::assign> _make_assign;
+    typedef functional::make_expr<tag::shift_left_assign> _make_shift_left_assign;
+    typedef functional::make_expr<tag::shift_right_assign> _make_shift_right_assign;
+    typedef functional::make_expr<tag::multiplies_assign> _make_multiplies_assign;
+    typedef functional::make_expr<tag::divides_assign> _make_divides_assign;
+    typedef functional::make_expr<tag::modulus_assign> _make_modulus_assign;
+    typedef functional::make_expr<tag::plus_assign> _make_plus_assign;
+    typedef functional::make_expr<tag::minus_assign> _make_minus_assign;
+    typedef functional::make_expr<tag::bitwise_and_assign> _make_bitwise_and_assign;
+    typedef functional::make_expr<tag::bitwise_or_assign> _make_bitwise_or_assign;
+    typedef functional::make_expr<tag::bitwise_xor_assign> _make_bitwise_xor_assign;
+    typedef functional::make_expr<tag::subscript> _make_subscript;
+    typedef functional::make_expr<tag::if_else_> _make_if_else;
+    typedef functional::make_expr<tag::function> _make_function;
+    template<typename T>
+    struct is_callable;
+    template<typename T>
+    struct is_transform;
+    template<typename T>
+    struct is_aggregate;
+    struct callable
+    {
+        typedef void proto_is_callable_;
+    };
+    struct external_transform;
+    template<typename PrimitiveTransform = void, typename X = void>
+    struct transform;
+    template<typename Grammar, typename Fun = Grammar>
+    struct when;
+    template<typename Fun>
+    struct otherwise;
+    template<typename Fun>
+    struct call;
+    template<typename Fun>
+    struct make;
+    template<typename PrimitiveTransform>
+    struct protect;
+    template<typename T>
+    struct noinvoke;
+    template<typename Fun>
+    struct lazy;
+    template<typename Sequence, typename State, typename Fun>
+    struct fold;
+    template<typename Sequence, typename State, typename Fun>
+    struct reverse_fold;
+    template<typename Sequence, typename State, typename Fun>
+    struct fold_tree;
+    template<typename Sequence, typename State, typename Fun>
+    struct reverse_fold_tree;
+    template<typename Grammar>
+    struct pass_through;
+    template<typename Grammar = detail::_default>
+    struct _default;
+    struct _expr;
+    struct _state;
+    struct _data;
+    struct _value;
+    struct _void;
+    template<typename T, T I>
+    struct integral_c;
+    template<char I>
+    struct char_;
+    template<int I>
+    struct int_;
+    template<long I>
+    struct long_;
+    template<std::size_t I>
+    struct size_t;
+    template<int I>
+    struct _child_c;
+    typedef _child_c<0> _child0;
+    typedef _child_c<1> _child1;
+    typedef _child0 _child;
+    typedef _child0 _left;
+    typedef _child1 _right;
+ typedef _child_c<2> _child2; typedef _child_c<3> _child3; typedef _child_c<4> _child4; typedef _child_c<5> _child5; typedef _child_c<6> _child6; typedef _child_c<7> _child7; typedef _child_c<8> _child8;
+    struct _byref;
+    struct _byval;
+    template<typename T>
+    struct is_extension;
+    namespace exops = exprns_;
+}}
+namespace boost {
+template< typename T > struct is_lvalue_reference : public ::boost::integral_constant<bool,false> { public: };
+template< typename T > struct is_lvalue_reference< T& > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace type_traits {
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+}
+}
+namespace boost {
+namespace type_traits {
+template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
+struct ice_or;
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_or
+{
+    static const bool value = true;
+};
+template <>
+struct ice_or<false, false, false, false, false, false, false>
+{
+    static const bool value = false;
+};
+}
+}
+namespace boost {
+namespace type_traits {
+template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
+struct ice_and;
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_and
+{
+    static const bool value = false;
+};
+template <>
+struct ice_and<true, true, true, true, true, true, true>
+{
+    static const bool value = true;
+};
+}
+}
+namespace boost {
+namespace type_traits {
+template <bool b>
+struct ice_not
+{
+    static const bool value = true;
+};
+template <>
+struct ice_not<true>
+{
+    static const bool value = false;
+};
+}
+}
+namespace boost {
+namespace type_traits {
+template <int b1, int b2>
+struct ice_eq
+{
+    static const bool value = (b1 == b2);
+};
+template <int b1, int b2>
+struct ice_ne
+{
+    static const bool value = (b1 != b2);
+};
+template <int b1, int b2> bool const ice_eq<b1,b2>::value;
+template <int b1, int b2> bool const ice_ne<b1,b2>::value;
+}
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct is_reference_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_lvalue_reference<T>::value, ::boost::is_rvalue_reference<T>::value >::value)
+                 ;
+};
+}
+template< typename T > struct is_reference : public ::boost::integral_constant<bool,::boost::detail::is_reference_impl<T>::value> { public: };
+}
+namespace boost {
+namespace type_traits {
+struct false_result
+{
+    template <typename T> struct result_
+    {
+        static const bool value = false;
+    };
+};
+}}
+namespace boost {
+namespace type_traits {
+template <class R>
+struct is_function_ptr_helper
+{
+    static const bool value = false;
+};
+template <class R >
+struct is_function_ptr_helper<R (*)()> { static const bool value = true; };
+template <class R >
+struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
+}
+}
+namespace boost {
+namespace detail {
+template<bool is_ref = true>
+struct is_function_chooser
+    : public ::boost::type_traits::false_result
+{
+};
+template <>
+struct is_function_chooser<false>
+{
+    template< typename T > struct result_
+        : public ::boost::type_traits::is_function_ptr_helper<T*>
+    {
+    };
+};
+template <typename T>
+struct is_function_impl
+    : public is_function_chooser< ::boost::is_reference<T>::value >
+        ::template result_<T>
+{
+};
+}
+template< typename T > struct is_function : public ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { public: };
+}
+namespace boost {
+template< typename T, typename U > struct is_same : public ::boost::integral_constant<bool,false> { public: };
+template< typename T > struct is_same< T,T > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct is_abstract_imp
+{
+   static const bool value = __is_abstract(T);
+};
+}
+template< typename T > struct is_abstract : public ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { public: };
+}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct value_type_wknd
+{
+    typedef typename T::value_type type;
+};
+}}}
+namespace mpl_ {
+struct void_;
+}
+namespace boost { namespace mpl { using ::mpl_::void_; } }
+namespace mpl_ {
+struct na
+{
+    typedef na type;
+    enum { value = 0 };
+};
+}
+namespace boost { namespace mpl { using ::mpl_::na; } }
+namespace boost { namespace mpl {
+template< typename T >
+struct is_na
+    : false_
+{
+};
+template<>
+struct is_na<na>
+    : true_
+{
+};
+template< typename T >
+struct is_not_na
+    : true_
+{
+};
+template<>
+struct is_not_na<na>
+    : false_
+{
+};
+template< typename T, typename U > struct if_na
+{
+    typedef T type;
+};
+template< typename U > struct if_na<na,U>
+{
+    typedef U type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    , typename Tag = void_
+    , typename Arity = int_< aux::template_arity<T>::value >
+    >
+struct lambda;
+}}
+namespace boost { namespace mpl {
+template<
+      bool C
+    , typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T1 type;
+};
+template<
+      typename T1
+    , typename T2
+    >
+struct if_c<false,T1,T2>
+{
+    typedef T2 type;
+};
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = na
+    >
+struct if_
+{
+ private:
+    typedef if_c<
+          static_cast<bool>(T1::value)
+        , T2
+        , T3
+        > almost_type_;
+ public:
+    typedef typename almost_type_::type type;
+};
+template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct nested_type_wknd
+    : T::type
+{
+};
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct or_impl
+    : true_
+{
+};
+template< typename T1, typename T2, typename T3, typename T4 >
+struct or_impl< false,T1,T2,T3,T4 >
+    : or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , false_
+        >
+{
+};
+template<>
+struct or_impl<
+          false
+        , false_, false_, false_, false_
+        >
+    : false_
+{
+};
+}
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = false_, typename T4 = false_, typename T5 = false_
+    >
+struct or_
+    : aux::or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+{
+};
+template<> struct or_<
+ na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }
+}}
+namespace mpl_ {
+struct void_ { typedef void_ type; };
+}
+namespace boost { namespace mpl {
+template< typename T >
+struct is_void_
+    : false_
+{
+};
+template<>
+struct is_void_<void_>
+    : true_
+{
+};
+template< typename T >
+struct is_not_void_
+    : true_
+{
+};
+template<>
+struct is_not_void_<void_>
+    : false_
+{
+};
+template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
+template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        yes_type check_is_iostream(
+            typename T::failure *
+          , typename T::Init *
+          , typename T::fmtflags *
+          , typename T::iostate *
+          , typename T::openmode *
+          , typename T::seekdir *
+        );
+        template<typename T>
+        no_type check_is_iostream(...);
+        template<typename T>
+        struct is_iostream
+        {
+            static bool const value = sizeof(yes_type) == sizeof(check_is_iostream<T>(0,0,0,0,0,0));
+            typedef mpl::bool_<value> type;
+        };
+        template<typename T>
+        struct ref_only
+          : mpl::or_<
+                is_function<T>
+              , is_abstract<T>
+              , is_iostream<T>
+            >
+        {};
+        template<typename Expr>
+        struct expr_traits
+        {
+            typedef Expr value_type;
+            typedef Expr &reference;
+            typedef Expr const &const_reference;
+        };
+        template<typename Expr>
+        struct expr_traits<Expr &>
+        {
+            typedef Expr value_type;
+            typedef Expr &reference;
+            typedef Expr &const_reference;
+        };
+        template<typename Expr>
+        struct expr_traits<Expr const &>
+        {
+            typedef Expr value_type;
+            typedef Expr const &reference;
+            typedef Expr const &const_reference;
+        };
+        template<typename T>
+        struct term_traits
+        {
+            typedef T value_type;
+            typedef T &reference;
+            typedef T const &const_reference;
+        };
+        template<typename T>
+        struct term_traits<T &>
+        {
+            typedef typename mpl::if_c<ref_only<T>::value, T &, T>::type value_type;
+            typedef T &reference;
+            typedef T &const_reference;
+        };
+        template<typename T>
+        struct term_traits<T const &>
+        {
+            typedef T value_type;
+            typedef T const &reference;
+            typedef T const &const_reference;
+        };
+        template<typename T, std::size_t N>
+        struct term_traits<T (&)[N]>
+        {
+            typedef T value_type[N];
+            typedef T (&reference)[N];
+            typedef T (&const_reference)[N];
+        };
+        template<typename T, std::size_t N>
+        struct term_traits<T const (&)[N]>
+        {
+            typedef T value_type[N];
+            typedef T const (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+        template<typename T, std::size_t N>
+        struct term_traits<T[N]>
+        {
+            typedef T value_type[N];
+            typedef T (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+        template<typename T, std::size_t N>
+        struct term_traits<T const[N]>
+        {
+            typedef T value_type[N];
+            typedef T const (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+    }
+    namespace argsns_
+    {
+    template< typename Arg0 >
+    struct term
+    {
+        static const long arity = 0;
+        typedef Arg0 child0;
+        typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg0 back_;
+    };
+    template< typename Arg0 >
+    struct list1
+    {
+        static const long arity = 1;
+        typedef Arg0 child0;
+        typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg0 back_;
+    };
+    template< typename Arg0 , typename Arg1 >
+    struct list2
+    {
+        static const long arity = 2;
+        typedef Arg0 child0; typedef Arg1 child1;
+        typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg1 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 >
+    struct list3
+    {
+        static const long arity = 3;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2;
+        typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg2 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct list4
+    {
+        static const long arity = 4;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3;
+        typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg3 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct list5
+    {
+        static const long arity = 5;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4;
+        typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg4 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct list6
+    {
+        static const long arity = 6;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5;
+        typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg5 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct list7
+    {
+        static const long arity = 7;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6;
+        typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg6 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct list8
+    {
+        static const long arity = 8;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7;
+        typedef mpl::void_ child8; typedef mpl::void_ child9;
+        typedef Arg7 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct list9
+    {
+        static const long arity = 9;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8;
+        typedef mpl::void_ child9;
+        typedef Arg8 back_;
+    };
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct list10
+    {
+        static const long arity = 10;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9;
+        typedef Arg9 back_;
+    };
+    }
+}}
+namespace boost { namespace proto { namespace tagns_ { namespace tag
+{
+    struct terminal {};
+    struct unary_plus {};
+    struct negate {};
+    struct dereference {};
+    struct complement {};
+    struct address_of {};
+    struct logical_not {};
+    struct pre_inc {};
+    struct pre_dec {};
+    struct post_inc {};
+    struct post_dec {};
+    struct shift_left {};
+    struct shift_right {};
+    struct multiplies {};
+    struct divides {};
+    struct modulus {};
+    struct plus {};
+    struct minus {};
+    struct less {};
+    struct greater {};
+    struct less_equal {};
+    struct greater_equal {};
+    struct equal_to {};
+    struct not_equal_to {};
+    struct logical_or {};
+    struct logical_and {};
+    struct bitwise_and {};
+    struct bitwise_or {};
+    struct bitwise_xor {};
+    struct comma {};
+    struct mem_ptr {};
+    struct assign {};
+    struct shift_left_assign {};
+    struct shift_right_assign {};
+    struct multiplies_assign {};
+    struct divides_assign {};
+    struct modulus_assign {};
+    struct plus_assign {};
+    struct minus_assign {};
+    struct bitwise_and_assign {};
+    struct bitwise_or_assign {};
+    struct bitwise_xor_assign {};
+    struct subscript {};
+    struct member {};
+    struct if_else_ {};
+    struct function {};
+}}}}
+namespace boost { namespace proto
+{
+    namespace result_of
+    {
+        template<typename Expr, typename Context>
+        struct eval
+        {
+            typedef typename Context::template eval<Expr>::result_type type;
+        };
+    }
+    namespace functional
+    {
+        struct eval
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr, typename Context>
+            struct result<This(Expr, Context)>
+            {
+                typedef
+                    typename proto::result_of::eval<
+                        typename remove_reference<Expr>::type
+                      , typename remove_reference<Context>::type
+                    >::type
+                type;
+            };
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr, Context>::type
+            operator ()(Expr &e, Context &ctx) const
+            {
+                return typename Context::template eval<Expr>()(e, ctx);
+            }
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr, Context>::type
+            operator ()(Expr &e, Context const &ctx) const
+            {
+                return typename Context::template eval<Expr>()(e, ctx);
+            }
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr const, Context>::type
+            operator ()(Expr const &e, Context &ctx) const
+            {
+                return typename Context::template eval<Expr const>()(e, ctx);
+            }
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr const, Context>::type
+            operator ()(Expr const &e, Context const &ctx) const
+            {
+                return typename Context::template eval<Expr const>()(e, ctx);
+            }
+        };
+    }
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr, Context>::type
+    eval(Expr &e, Context &ctx)
+    {
+        return typename Context::template eval<Expr>()(e, ctx);
+    }
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr, Context>::type
+    eval(Expr &e, Context const &ctx)
+    {
+        return typename Context::template eval<Expr>()(e, ctx);
+    }
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr const, Context>::type
+    eval(Expr const &e, Context &ctx)
+    {
+        return typename Context::template eval<Expr const>()(e, ctx);
+    }
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr const, Context>::type
+    eval(Expr const &e, Context const &ctx)
+    {
+        return typename Context::template eval<Expr const>()(e, ctx);
+    }
+}}
+namespace boost{
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+template<int x> struct static_assert_test{};
+}
+namespace boost { namespace proto { namespace detail
+{
+    sized_type<1>::type template_arity_helper(...);
+    template<
+        template<typename P0> class F
+      , typename T0
+    >
+    sized_type<2>::type
+    template_arity_helper(F<T0> **, mpl::int_<1> *);
+    template<
+        template<typename P0 , typename P1> class F
+      , typename T0 , typename T1
+    >
+    sized_type<3>::type
+    template_arity_helper(F<T0 , T1> **, mpl::int_<2> *);
+    template<
+        template<typename P0 , typename P1 , typename P2> class F
+      , typename T0 , typename T1 , typename T2
+    >
+    sized_type<4>::type
+    template_arity_helper(F<T0 , T1 , T2> **, mpl::int_<3> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3> class F
+      , typename T0 , typename T1 , typename T2 , typename T3
+    >
+    sized_type<5>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3> **, mpl::int_<4> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+    >
+    sized_type<6>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4> **, mpl::int_<5> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+    >
+    sized_type<7>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5> **, mpl::int_<6> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+    >
+    sized_type<8>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6> **, mpl::int_<7> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+    >
+    sized_type<9>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> **, mpl::int_<8> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+    >
+    sized_type<10>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> **, mpl::int_<9> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8 , typename P9> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+    >
+    sized_type<11>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> **, mpl::int_<10> *);
+    template<typename F, int N, int Size>
+    struct template_arity_impl2
+      : mpl::int_<Size - 1>
+    {};
+    template<typename F, int N = 10>
+    struct template_arity
+      : template_arity_impl2<
+            F
+          , N
+          , sizeof(detail::template_arity_helper((F **)0, (mpl::int_<N> *)0))
+        >
+    {};
+    template<typename F, int N>
+    struct template_arity_impl2<F, N, 1>
+      : template_arity<F, N-1>
+    {};
+    template<typename F>
+    struct template_arity_impl2<F, 0, 1>
+      : mpl::int_<-1>
+    {};
+}}}
+namespace boost {
+template< typename T > struct is_void : public ::boost::integral_constant<bool,false> { public: };
+template<> struct is_void< void > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_void< void const > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_void< void volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_void< void const volatile > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+template< typename T > struct is_integral : public ::boost::integral_constant<bool,false> { public: };
+template<> struct is_integral< unsigned char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned char const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< unsigned short > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned short const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< unsigned int > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned int const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< unsigned long > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< unsigned long const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< signed char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed char const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< signed short > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed short const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< signed int > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed int const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< signed long > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< signed long const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< bool > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< bool const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< char > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< char const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< wchar_t > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< wchar_t const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< ::boost::ulong_long_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_integral< ::boost::long_long_type > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_integral< ::boost::long_long_type const volatile > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+template< typename T > struct is_float : public ::boost::integral_constant<bool,false> { public: };
+template<> struct is_float< float > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< float const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_float< double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< double const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_float< long double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_float< long double const volatile > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+namespace detail {
+template< typename T >
+struct is_arithmetic_impl
+{
+    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value)
+                  ;
+};
+}
+template< typename T > struct is_arithmetic : public ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { public: };
+}
+namespace boost {
+template< typename T > struct is_enum : public ::boost::integral_constant<bool,__is_enum(T)> { public: };
+}
+namespace boost {
+namespace type_traits {
+template <typename T>
+struct is_mem_fun_pointer_impl
+{
+    static const bool value = false;
+};
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
+}
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct rvalue_ref_filter_rem_cv
+{
+   typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
+};
+}
+template< typename T > struct remove_cv { public: typedef typename boost::detail::rvalue_ref_filter_rem_cv<T>::type type; };
+template< typename T > struct remove_cv<T&> { public: typedef T& type; };
+template< typename T, std::size_t N > struct remove_cv<T const[N]> { public: typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { public: typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { public: typedef T type[N]; };
+}
+namespace boost {
+template< typename T > struct is_member_function_pointer : public ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> { public: };
+}
+namespace boost {
+template< typename T > struct is_member_pointer : public ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { public: };
+template< typename T, typename U > struct is_member_pointer< U T::* > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, typename U > struct is_member_pointer< U T::*const > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, typename U > struct is_member_pointer< U T::*volatile > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, typename U > struct is_member_pointer< U T::*const volatile > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+namespace detail {
+template< typename T > struct is_pointer_helper
+{
+    static const bool value = false;
+};
+template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
+template< typename T >
+struct is_pointer_impl
+{
+    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value)
+         ;
+};
+}
+template< typename T > struct is_pointer : public ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct is_scalar_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value)
+                ;
+};
+template <> struct is_scalar_impl<void>{ static const bool value = false; };
+template <> struct is_scalar_impl<void const>{ static const bool value = false; };
+template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
+template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };
+}
+template< typename T > struct is_scalar : public ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { public: };
+}
+namespace boost {
+template< typename T > struct is_POD;
+namespace detail {
+template <typename T> struct is_pod_impl
+{
+    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, __is_pod(T) >::value)
+                   ;
+};
+template <typename T, std::size_t sz>
+struct is_pod_impl<T[sz]>
+    : public is_pod_impl<T>
+{
+};
+template<> struct is_pod_impl< void > { public: static const bool value = (true); };
+template<> struct is_pod_impl< void const > { public: static const bool value = (true); };
+template<> struct is_pod_impl< void volatile > { public: static const bool value = (true); };
+template<> struct is_pod_impl< void const volatile > { public: static const bool value = (true); };
+}
+template< typename T > struct is_POD : public ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { public: };
+template< typename T > struct is_pod : public ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { public: };
+}
+namespace boost {
+template< typename T > struct add_const { public: typedef T const type; };
+template< typename T > struct add_const<T&> { public: typedef T& type; };
+}
+namespace boost
+{
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+  template <class T>
+  struct enable_if_c<false, T> {};
+  template <class Cond, class T = void>
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+  template <class Cond, class T>
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+  template <class T>
+  struct disable_if_c<true, T> {};
+  template <class Cond, class T = void>
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+  template <class Cond, class T>
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct type_wrapper
+{
+    typedef T type;
+};
+template< typename T > struct wrapped_type;
+template< typename T > struct wrapped_type< type_wrapper<T> >
+{
+    typedef T type;
+};
+}}}
+namespace boost { namespace mpl { namespace aux {
+typedef char (&no_tag)[1];
+typedef char (&yes_tag)[2];
+template< bool C_ > struct yes_no_tag
+{
+    typedef no_tag type;
+};
+template<> struct yes_no_tag<true>
+{
+    typedef yes_tag type;
+};
+template< long n > struct weighted_tag
+{
+    typedef char (&type)[n];
+};
+}}}
+namespace boost {
+namespace type_traits_detail {
+    template <typename T, bool b>
+    struct add_rvalue_reference_helper
+    { typedef T type; };
+    template <typename T>
+    struct add_rvalue_reference_imp
+    {
+       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
+                  <T, (!is_void<T>::value && !is_reference<T>::value) >::type type;
+    };
+}
+template< typename T > struct add_rvalue_reference { public: typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; };
+}
+namespace boost {
+    template <typename T>
+    typename add_rvalue_reference<T>::type declval();
+}
+namespace boost {
+template<typename F> struct result_of;
+template<typename F> struct tr1_result_of;
+namespace detail {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_result_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::result_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
+template<typename F> struct cpp0x_result_of_impl;
+template<typename F>
+struct result_of_void_impl
+{
+  typedef void type;
+};
+template<typename R>
+struct result_of_void_impl<R (*)(void)>
+{
+  typedef R type;
+};
+template<typename R>
+struct result_of_void_impl<R (&)(void)>
+{
+  typedef R type;
+};
+template<typename F, typename FArgs>
+struct result_of_pointer
+  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, true>
+{
+  typedef typename F::result_type type;
+};
+template<typename FArgs>
+struct is_function_with_no_args : mpl::false_ {};
+template<typename F>
+struct is_function_with_no_args<F(void)> : mpl::true_ {};
+template<typename F, typename FArgs>
+struct result_of_nested_result : F::template result<FArgs>
+{};
+template<typename F, typename FArgs>
+struct tr1_result_of_impl<F, FArgs, false>
+  : mpl::if_<is_function_with_no_args<FArgs>,
+             result_of_void_impl<F>,
+             result_of_nested_result<F, FArgs> >::type
+{};
+}
+template<typename F
+         >
+struct tr1_result_of<F()>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type(),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F(),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F
+         >
+struct result_of<F()>
+    : tr1_result_of<F()> { };
+template<typename F ,
+         typename T0>
+struct tr1_result_of<F( T0)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0>
+struct result_of<F( T0)>
+    : tr1_result_of<F( T0)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (*)( T0), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (&)( T0), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (T0::*)
+                     (),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (T0::*)
+                     ()
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (T0::*)
+                     ()
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0>
+struct tr1_result_of_impl<R (T0::*)
+                     ()
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1>
+struct tr1_result_of<F( T0 , T1)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1>
+struct result_of<F( T0 , T1)>
+    : tr1_result_of<F( T0 , T1)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (*)( T0 , T1), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (&)( T0 , T1), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of<F( T0 , T1 , T2)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2>
+struct result_of<F( T0 , T1 , T2)>
+    : tr1_result_of<F( T0 , T1 , T2)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of<F( T0 , T1 , T2 , T3)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct result_of<F( T0 , T1 , T2 , T3)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct result_of<F( T0 , T1 , T2 , T3 , T4)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4 , T5),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4 , T5 , T6),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
+    : mpl::if_<
+          mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
+        , boost::detail::tr1_result_of_impl<
+            typename remove_cv<F>::type,
+            typename remove_cv<F>::type( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
+            (boost::detail::has_result_type<F>::value)>
+        , boost::detail::tr1_result_of_impl<
+            F,
+            F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
+            (boost::detail::has_result_type<F>::value)> >::type { };
+template<typename F ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
+    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { };
+namespace detail {
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9),
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+                     const,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+                     volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+template<typename R, typename FArgs ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+struct tr1_result_of_impl<R (T0::*)
+                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+                     const volatile,
+                 FArgs, false>
+{
+  typedef R type;
+};
+}
+}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr>
+        struct by_value_generator_;
+        template<typename Tag, typename Arg>
+        struct by_value_generator_<proto::expr<Tag, term<Arg>, 0> >
+        {
+            typedef
+                proto::expr<
+                    Tag
+                  , term<typename detail::term_traits<Arg>::value_type>
+                  , 0
+                >
+            type;
+            inline __attribute__ ((always_inline))
+            static type const call(proto::expr<Tag, term<Arg>, 0> const &e)
+            {
+                type that = {e.child0};
+                return that;
+            }
+        };
+        template<typename Tag, typename Arg>
+        struct by_value_generator_<proto::basic_expr<Tag, term<Arg>, 0> >
+        {
+            typedef
+                proto::basic_expr<
+                    Tag
+                  , term<typename detail::term_traits<Arg>::value_type>
+                  , 0
+                >
+            type;
+            inline __attribute__ ((always_inline))
+            static type const call(proto::basic_expr<Tag, term<Arg>, 0> const &e)
+            {
+                type that = {e.child0};
+                return that;
+            }
+        };
+    template<typename Tag , typename Arg0 >
+    struct by_value_generator_<
+        proto::expr<Tag, list1<Arg0>, 1>
+    >
+    {
+        typedef
+            list1<Arg0>
+        src_args;
+        typedef
+            list1<
+                typename uncvref<Arg0 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 1> src_type;
+        typedef proto::expr<Tag, dst_args, 1> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list1<Arg0>, 1>
+    >
+    {
+        typedef
+            list1<Arg0>
+        src_args;
+        typedef
+            list1<
+                typename uncvref<Arg0 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 1> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 1> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 >
+    struct by_value_generator_<
+        proto::expr<Tag, list2<Arg0 , Arg1>, 2>
+    >
+    {
+        typedef
+            list2<Arg0 , Arg1>
+        src_args;
+        typedef
+            list2<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 2> src_type;
+        typedef proto::expr<Tag, dst_args, 2> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list2<Arg0 , Arg1>, 2>
+    >
+    {
+        typedef
+            list2<Arg0 , Arg1>
+        src_args;
+        typedef
+            list2<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 2> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 2> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
+    struct by_value_generator_<
+        proto::expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
+    >
+    {
+        typedef
+            list3<Arg0 , Arg1 , Arg2>
+        src_args;
+        typedef
+            list3<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 3> src_type;
+        typedef proto::expr<Tag, dst_args, 3> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
+    >
+    {
+        typedef
+            list3<Arg0 , Arg1 , Arg2>
+        src_args;
+        typedef
+            list3<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 3> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 3> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct by_value_generator_<
+        proto::expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
+    >
+    {
+        typedef
+            list4<Arg0 , Arg1 , Arg2 , Arg3>
+        src_args;
+        typedef
+            list4<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 4> src_type;
+        typedef proto::expr<Tag, dst_args, 4> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
+    >
+    {
+        typedef
+            list4<Arg0 , Arg1 , Arg2 , Arg3>
+        src_args;
+        typedef
+            list4<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 4> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 4> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct by_value_generator_<
+        proto::expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
+    >
+    {
+        typedef
+            list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
+        src_args;
+        typedef
+            list5<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 5> src_type;
+        typedef proto::expr<Tag, dst_args, 5> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
+    >
+    {
+        typedef
+            list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
+        src_args;
+        typedef
+            list5<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 5> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 5> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct by_value_generator_<
+        proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+    >
+    {
+        typedef
+            list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+        src_args;
+        typedef
+            list6<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 6> src_type;
+        typedef proto::expr<Tag, dst_args, 6> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+    >
+    {
+        typedef
+            list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+        src_args;
+        typedef
+            list6<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 6> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 6> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct by_value_generator_<
+        proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+    >
+    {
+        typedef
+            list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+        src_args;
+        typedef
+            list7<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 7> src_type;
+        typedef proto::expr<Tag, dst_args, 7> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+    >
+    {
+        typedef
+            list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+        src_args;
+        typedef
+            list7<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 7> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 7> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct by_value_generator_<
+        proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+    >
+    {
+        typedef
+            list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+        src_args;
+        typedef
+            list8<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 8> src_type;
+        typedef proto::expr<Tag, dst_args, 8> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+    >
+    {
+        typedef
+            list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+        src_args;
+        typedef
+            list8<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 8> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 8> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct by_value_generator_<
+        proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+    >
+    {
+        typedef
+            list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+        src_args;
+        typedef
+            list9<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 9> src_type;
+        typedef proto::expr<Tag, dst_args, 9> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+    >
+    {
+        typedef
+            list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+        src_args;
+        typedef
+            list9<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 9> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 9> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct by_value_generator_<
+        proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+    >
+    {
+        typedef
+            list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+        src_args;
+        typedef
+            list10<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 10> src_type;
+        typedef proto::expr<Tag, dst_args, 10> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+    >
+    {
+        typedef
+            list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+        src_args;
+        typedef
+            list10<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 10> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 10> type;
+        inline __attribute__ ((always_inline))
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+            };
+            return that;
+        }
+    };
+    }
+    template<typename Generator>
+    struct use_basic_expr
+      : Generator
+    {
+        typedef void proto_use_basic_expr_;
+    };
+    struct default_generator
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Expr type;
+        };
+        template<typename Expr>
+        inline __attribute__ ((always_inline))
+        Expr const &
+        operator ()(Expr const &e) const
+        {
+            return e;
+        }
+    };
+    struct basic_default_generator
+      : proto::use_basic_expr<default_generator>
+    {};
+    template<template<typename> class Extends>
+    struct generator
+    {
+        typedef void proto_is_callable_;
+        typedef void proto_use_basic_expr_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename Expr>
+        inline __attribute__ ((always_inline))
+        Extends<Expr> operator ()(Expr const &e) const
+        {
+            return Extends<Expr>(e);
+        }
+    };
+    template<template<typename> class Extends>
+    struct pod_generator
+    {
+        typedef void proto_is_callable_;
+        typedef void proto_use_basic_expr_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef Extends<Expr> type;
+        };
+        template<typename Expr>
+        inline __attribute__ ((always_inline))
+        Extends<Expr> operator ()(Expr const &e) const
+        {
+            Extends<Expr> that = {e};
+            return that;
+        }
+    };
+    struct by_value_generator
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef
+                typename detail::by_value_generator_<Expr>::type
+            type;
+        };
+        template<typename Expr>
+        inline __attribute__ ((always_inline))
+        typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
+        {
+            return detail::by_value_generator_<Expr>::call(e);
+        }
+    };
+    template<typename First, typename Second>
+    struct compose_generators
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+        template<typename This, typename Expr>
+        struct result<This(Expr const &)>
+        {
+            typedef
+                typename Second::template result<
+                    Second(typename First::template result<First(Expr)>::type)
+                >::type
+            type;
+        };
+        template<typename Expr>
+        inline __attribute__ ((always_inline))
+        typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
+        {
+            return Second()(First()(e));
+        }
+    };
+    template<typename Generator, typename Void>
+    struct wants_basic_expr
+      : mpl::false_
+    {};
+    template<typename Generator>
+    struct wants_basic_expr<Generator, typename Generator::proto_use_basic_expr_>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<default_generator>
+      : mpl::true_
+    {};
+    template<template<typename> class Extends>
+    struct is_callable<generator<Extends> >
+      : mpl::true_
+    {};
+    template<template<typename> class Extends>
+    struct is_callable<pod_generator<Extends> >
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<by_value_generator>
+      : mpl::true_
+    {};
+    template<typename First, typename Second>
+    struct is_callable<compose_generators<First, Second> >
+      : mpl::true_
+    {};
+}}
+namespace boost
+{
+    template<typename Expr>
+    struct result_of<proto::default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct result_of<proto::basic_default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct result_of<proto::default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct result_of<proto::basic_default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct tr1_result_of<proto::default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct tr1_result_of<proto::basic_default_domain(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct tr1_result_of<proto::default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+    template<typename Expr>
+    struct tr1_result_of<proto::basic_default_generator(Expr)>
+    {
+        typedef Expr type;
+    };
+}
+namespace boost { namespace proto { namespace detail
+{
+    template<typename Generator>
+    struct base_generator
+    {
+        typedef Generator type;
+    };
+    template<typename Generator>
+    struct base_generator<use_basic_expr<Generator> >
+    {
+        typedef Generator type;
+    };
+    template<typename T, typename Generator, bool WantsBasicExpr>
+    struct as_expr;
+    template<typename T, typename Generator>
+    struct as_expr<T, Generator, false>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+    template<typename T, typename Generator>
+    struct as_expr<T, Generator, true>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+    template<typename T>
+    struct as_expr<T, proto::default_generator, false>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::expr<proto::tag::terminal, term<value_type>, 0> result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+    template<typename T>
+    struct as_expr<T, proto::default_generator, true>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+    template<typename T, typename Generator, bool WantsBasicExpr>
+    struct as_child;
+    template<typename T, typename Generator>
+    struct as_child<T, Generator, false>
+    {
+        typedef T &reference;
+        typedef proto::expr<proto::tag::terminal, term<reference>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+    template<typename T, typename Generator>
+    struct as_child<T, Generator, true>
+    {
+        typedef T &reference;
+        typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+    template<typename T>
+    struct as_child<T, proto::default_generator, false>
+    {
+        typedef T &reference;
+        typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+    template<typename T>
+    struct as_child<T, proto::default_generator, true>
+    {
+        typedef T &reference;
+        typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< long C_ >
+struct not_impl
+    : bool_<!C_>
+{
+};
+}
+template<
+      typename T = na
+    >
+struct not_
+    : aux::not_impl<
+          ::boost::mpl::aux::nested_type_wknd<T>::value
+        >
+{
+};
+template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }
+}}
+namespace mpl_ {
+struct failed {};
+template< bool C > struct assert { typedef void* type; };
+template<> struct assert<false> { typedef assert type; };
+template< bool C >
+int assertion_failed( typename assert<C>::type );
+template< bool C >
+struct assertion
+{
+    static int failed( assert<false> );
+};
+template<>
+struct assertion<true>
+{
+    static int failed( void* );
+};
+struct assert_
+{
+    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
+    static assert_ const arg;
+    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
+};
+boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
+boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
+boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
+boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );
+template< assert_::relations r, long x, long y > struct assert_relation {};
+template< bool > struct assert_arg_pred_impl { typedef int type; };
+template<> struct assert_arg_pred_impl<true> { typedef void* type; };
+template< typename P > struct assert_arg_pred
+{
+    typedef typename P::type p_type;
+    typedef typename assert_arg_pred_impl< p_type::value >::type type;
+};
+template< typename P > struct assert_arg_pred_not
+{
+    typedef typename P::type p_type;
+    enum { p = !p_type::value };
+    typedef typename assert_arg_pred_impl<p>::type type;
+};
+template< typename Pred >
+failed ************ (Pred::************
+      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
+    );
+template< typename Pred >
+failed ************ (boost::mpl::not_<Pred>::************
+      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
+    );
+template< typename Pred >
+assert<false>
+assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
+template< typename Pred >
+assert<false>
+assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
+}
+namespace boost
+{
+    namespace proto
+    {
+        namespace detail
+        {
+            template<typename Domain>
+            struct domain_
+              : domain_<typename Domain::proto_super_domain>
+            {
+                typedef Domain type;
+                typedef domain_<typename Domain::proto_super_domain> base;
+                using base::deduce98;
+                static int const index = base::index + 1;
+                static typename sized_type<index>::type deduce98(domain_<Domain>*);
+            };
+            template<>
+            struct domain_<not_a_domain>
+            {
+                typedef not_a_domain type;
+                static int const index = 1;
+                static sized_type<1>::type deduce98(void*);
+            };
+            template<>
+            struct domain_<default_domain>
+              : domain_<not_a_domain>
+            {};
+            template<>
+            struct domain_<basic_default_domain>
+              : domain_<not_a_domain>
+            {};
+            sized_type<1>::type default_test(void*, void*);
+            sized_type<2>::type default_test(domain_<default_domain>*, void*);
+            sized_type<2>::type default_test(domain_<basic_default_domain>*, void*);
+            sized_type<3>::type default_test(void*, domain_<default_domain>*);
+            sized_type<3>::type default_test(void*, domain_<basic_default_domain>*);
+            sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*);
+            sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*);
+            sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*);
+            sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*);
+            template<int N, typename Domain>
+            struct nth_domain
+              : nth_domain<N - 1, typename Domain::base>
+            {};
+            template<typename Domain>
+            struct nth_domain<0, Domain>
+              : Domain
+            {};
+            template<typename D0>
+            struct common_domain1
+            {
+                typedef D0 type;
+            };
+            template<typename E0>
+            struct deduce_domain1
+              : domain_of<E0>
+            {};
+            template<
+                typename D0
+              , typename D1
+              , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0))
+            >
+            struct common_domain2
+            {
+                static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0));
+                typedef typename nth_domain<index, domain_<D0> >::type type;
+            };
+            template<typename D0, typename D1>
+            struct common_domain2<D0, D1, 2>
+            {
+                typedef D1 type;
+            };
+            template<typename D0, typename D1>
+            struct common_domain2<D0, D1, 3>
+            {
+                typedef D0 type;
+            };
+            template<typename D0>
+            struct common_domain2<D0, default_domain, 4>
+            {
+                typedef D0 type;
+            };
+            template<typename D0>
+            struct common_domain2<D0, basic_default_domain, 4>
+            {
+                typedef D0 type;
+            };
+            template<typename D1>
+            struct common_domain2<default_domain, D1, 4>
+            {
+                typedef D1 type;
+            };
+            template<typename D1>
+            struct common_domain2<basic_default_domain, D1, 4>
+            {
+                typedef D1 type;
+            };
+            template<>
+            struct common_domain2<default_domain, default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+            template<>
+            struct common_domain2<basic_default_domain, default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+            template<>
+            struct common_domain2<default_domain, basic_default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+            template<>
+            struct common_domain2<basic_default_domain, basic_default_domain, 4>
+            {
+                typedef basic_default_domain type;
+            };
+            template<typename E0, typename E1>
+            struct deduce_domain2
+              : common_domain2<
+                    typename domain_of<E0>::type
+                  , typename domain_of<E1>::type
+                >
+            {};
+    template<typename A0 , typename A1 , typename A2>
+    struct common_domain3
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3;
+        typedef common3 type;
+        enum { mpl_assertion_in_line_14 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2>
+    struct deduce_domain3
+      : common_domain3<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    struct common_domain4
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4;
+        typedef common4 type;
+        enum { mpl_assertion_in_line_28 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3>
+    struct deduce_domain4
+      : common_domain4<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct common_domain5
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5;
+        typedef common5 type;
+        enum { mpl_assertion_in_line_42 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4>
+    struct deduce_domain5
+      : common_domain5<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct common_domain6
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6;
+        typedef common6 type;
+        enum { mpl_assertion_in_line_56 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5>
+    struct deduce_domain6
+      : common_domain6<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct common_domain7
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7;
+        typedef common7 type;
+        enum { mpl_assertion_in_line_70 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6>
+    struct deduce_domain7
+      : common_domain7<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct common_domain8
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8;
+        typedef common8 type;
+        enum { mpl_assertion_in_line_84 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7>
+    struct deduce_domain8
+      : common_domain8<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct common_domain9
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9;
+        typedef common9 type;
+        enum { mpl_assertion_in_line_98 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8>
+    struct deduce_domain9
+      : common_domain9<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct common_domain10
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef typename common_domain2<common9, A9>::type common10;
+        typedef common10 type;
+        enum { mpl_assertion_in_line_112 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::is_same<type, boost::proto::detail::not_a_domain>))0, 1 ) ) ) };
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8 , typename E9>
+    struct deduce_domain10
+      : common_domain10<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type , typename domain_of<E9 >::type
+        >
+    {};
+        }
+    }
+}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        struct not_a_generator
+        {};
+        struct not_a_grammar
+        {};
+        struct not_a_domain
+        {};
+    }
+    namespace domainns_
+    {
+        template<
+            typename Generator
+          , typename Grammar
+          , typename Super
+        >
+        struct domain
+          : Generator
+        {
+            typedef Generator proto_generator;
+            typedef Grammar proto_grammar;
+            typedef Super proto_super_domain;
+            typedef domain proto_base_domain;
+            typedef void proto_is_domain_;
+            template<typename T, typename IsExpr = void, typename Callable = proto::callable>
+            struct as_expr
+              : detail::as_expr<
+                    T
+                  , typename detail::base_generator<Generator>::type
+                  , wants_basic_expr<Generator>::value
+                >
+            {
+                typedef void proto_is_callable_;
+            };
+            template<typename T>
+            struct as_expr<T, typename T::proto_is_expr_, proto::callable>
+            {
+                typedef void proto_is_callable_;
+                typedef typename remove_const<T>::type result_type;
+                inline __attribute__ ((always_inline))
+                result_type operator()(T &e) const
+                {
+                    return e;
+                }
+            };
+            template<typename T, typename IsExpr = void, typename Callable = proto::callable>
+            struct as_child
+              : detail::as_child<
+                    T
+                  , typename detail::base_generator<Generator>::type
+                  , wants_basic_expr<Generator>::value
+                >
+            {
+                typedef void proto_is_callable_;
+            };
+            template<typename T>
+            struct as_child<T, typename T::proto_is_expr_, proto::callable>
+            {
+                typedef void proto_is_callable_;
+                typedef T &result_type;
+                inline __attribute__ ((always_inline))
+                result_type operator()(T &e) const
+                {
+                    return e;
+                }
+            };
+        };
+        struct default_domain
+          : domain<>
+        {};
+        struct basic_default_domain
+          : domain<basic_default_generator>
+        {};
+        struct deduce_domain
+          : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain>
+        {};
+        template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr>
+        struct base_expr
+        {
+            typedef proto::expr<Tag, Args, Args::arity> type;
+        };
+        template<typename Domain, typename Tag, typename Args>
+        struct base_expr<Domain, Tag, Args, true>
+        {
+            typedef proto::basic_expr<Tag, Args, Args::arity> type;
+        };
+    }
+    template<typename T, typename Void >
+    struct is_domain
+      : mpl::false_
+    {};
+    template<typename T>
+    struct is_domain<T, typename T::proto_is_domain_>
+      : mpl::true_
+    {};
+    template<typename T, typename Void >
+    struct domain_of
+    {
+        typedef default_domain type;
+    };
+    template<typename T>
+    struct domain_of<T, typename T::proto_is_expr_>
+    {
+        typedef typename T::proto_domain type;
+    };
+    template<typename T>
+    struct domain_of<T &, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+    template<typename T>
+    struct domain_of<boost::reference_wrapper<T>, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+    template<typename T>
+    struct domain_of<boost::reference_wrapper<T> const, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+    template<typename SubDomain, typename SuperDomain>
+    struct is_sub_domain_of
+      : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain>
+    {};
+    template<typename SuperDomain>
+    struct is_sub_domain_of<proto::no_super_domain, SuperDomain>
+      : mpl::false_
+    {};
+    template<typename SuperDomain>
+    struct is_sub_domain_of<SuperDomain, SuperDomain>
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Sig>
+        struct apply_transform;
+        template<typename PrimitiveTransform, typename Expr>
+        struct apply_transform<PrimitiveTransform(Expr)>
+          : PrimitiveTransform::template impl<Expr, int, int>
+        {};
+        template<typename PrimitiveTransform, typename Expr, typename State>
+        struct apply_transform<PrimitiveTransform(Expr, State)>
+          : PrimitiveTransform::template impl<Expr, State, int>
+        {};
+        template<typename PrimitiveTransform, typename Expr, typename State, typename Data>
+        struct apply_transform<PrimitiveTransform(Expr, State, Data)>
+          : PrimitiveTransform::template impl<Expr, State, Data>
+        {};
+    }
+    template<typename PrimitiveTransform, typename X>
+    struct transform
+    {
+        typedef void proto_is_callable_; typedef X proto_is_transform_; typedef PrimitiveTransform transform_type; template<typename Sig> struct result { typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; }; template<typename Expr> inline __attribute__ ((always_inline)) typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type operator ()(Expr &e) const { int i = 0; return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, i, i); } template<typename Expr, typename State> inline __attribute__ ((always_inline)) typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type operator ()(Expr &e, State &s) const { int i = 0; return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, i); } template<typename Expr, typename State> inline __attribute__ ((always_inline)) typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type operator ()(Expr &e, State const &s) const { int i = 0; return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, i); } template<typename Expr, typename State, typename Data> inline __attribute__ ((always_inline)) typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type operator ()(Expr &e, State &s, Data &d) const { return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); } template<typename Expr, typename State, typename Data> inline __attribute__ ((always_inline)) typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type operator ()(Expr &e, State const &s, Data &d) const { return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); }
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl
+    {
+        typedef Expr const expr;
+        typedef Expr const &expr_param;
+        typedef State const state;
+        typedef State const &state_param;
+        typedef Data const data;
+        typedef Data const &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr &, State, Data>
+    {
+        typedef Expr expr;
+        typedef Expr &expr_param;
+        typedef State const state;
+        typedef State const &state_param;
+        typedef Data const data;
+        typedef Data const &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr, State &, Data>
+    {
+        typedef Expr const expr;
+        typedef Expr const &expr_param;
+        typedef State state;
+        typedef State &state_param;
+        typedef Data const data;
+        typedef Data const &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr, State, Data &>
+    {
+        typedef Expr const expr;
+        typedef Expr const &expr_param;
+        typedef State const state;
+        typedef State const &state_param;
+        typedef Data data;
+        typedef Data &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr &, State &, Data>
+    {
+        typedef Expr expr;
+        typedef Expr &expr_param;
+        typedef State state;
+        typedef State &state_param;
+        typedef Data const data;
+        typedef Data const &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr &, State, Data &>
+    {
+        typedef Expr expr;
+        typedef Expr &expr_param;
+        typedef State const state;
+        typedef State const &state_param;
+        typedef Data data;
+        typedef Data &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr, State &, Data &>
+    {
+        typedef Expr const expr;
+        typedef Expr const &expr_param;
+        typedef State state;
+        typedef State &state_param;
+        typedef Data data;
+        typedef Data &data_param;
+    };
+    template<typename Expr, typename State, typename Data>
+    struct transform_impl<Expr &, State &, Data &>
+    {
+        typedef Expr expr;
+        typedef Expr &expr_param;
+        typedef State state;
+        typedef State &state_param;
+        typedef Data data;
+        typedef Data &data_param;
+    };
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        inline __attribute__ ((always_inline)) void ignore_unused(T const &)
+        {}
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<
+            typename Grammar
+          , typename Expr
+          , typename State
+          , typename Data
+          , long Arity = arity_of<Expr>::value
+        >
+        struct pass_through_impl
+        {};
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 1>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list1<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 2>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list2<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 3>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list3<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 4>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list4<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 5>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list5<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 6>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list6<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 7>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list7<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 8>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list8<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 9>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list9<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct pass_through_impl<Grammar, Expr, State, Data, 10>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename pass_through_impl::expr unref_expr;
+        typedef
+            typename base_expr<
+                typename unref_expr::proto_domain
+              , typename unref_expr::proto_tag
+              , list10<
+                    typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename unref_expr::proto_generator proto_generator;
+        typedef typename boost::tr1_result_of<proto_generator(expr_type)>::type const result_type;
+        inline __attribute__ ((always_inline))
+        result_type const operator ()(
+            typename pass_through_impl::expr_param e
+          , typename pass_through_impl::state_param s
+          , typename pass_through_impl::data_param d
+        ) const
+        {
+            expr_type const that = {
+                typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >()( e.proto_base().child9, s, d )
+            };
+            detail::ignore_unused(&that);
+            return proto_generator()(that);
+        }
+    };
+        template<typename Grammar, typename Expr, typename State, typename Data>
+        struct pass_through_impl<Grammar, Expr, State, Data, 0>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            inline __attribute__ ((always_inline))
+            typename pass_through_impl::expr_param
+            operator()(
+                typename pass_through_impl::expr_param e
+              , typename pass_through_impl::state_param
+              , typename pass_through_impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+    }
+    template<typename Grammar>
+    struct pass_through
+      : transform<pass_through<Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::pass_through_impl<Grammar, Expr, State, Data>
+        {};
+    };
+    template<typename Grammar>
+    struct is_callable<pass_through<Grammar> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T, typename Void = void>
+        struct if_vararg
+        {};
+        template<typename T>
+        struct if_vararg<T, typename T::proto_is_vararg_>
+          : T
+        {};
+        template<typename T, typename Void = void>
+        struct is_callable2_
+          : mpl::false_
+        {};
+        template<typename T>
+        struct is_callable2_<T, typename T::proto_is_callable_>
+          : mpl::true_
+        {};
+        template<typename T , long Arity = boost::proto::detail::template_arity<T>::value>
+        struct is_callable_
+          : is_callable2_<T>
+        {};
+    }
+    template<typename T>
+    struct is_callable
+      : proto::detail::is_callable_<T>
+    {};
+    template<>
+    struct is_callable<proto::_>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<proto::callable>
+      : mpl::false_
+    {};
+    template<typename PrimitiveTransform, typename X>
+    struct is_callable<proto::transform<PrimitiveTransform, X> >
+      : mpl::false_
+    {};
+    namespace detail
+    {
+        template<typename T, typename Void >
+        struct is_transform_
+          : mpl::false_
+        {};
+        template<typename T>
+        struct is_transform_<T, typename T::proto_is_transform_>
+          : mpl::true_
+        {};
+    }
+    template<typename T>
+    struct is_transform
+      : proto::detail::is_transform_<T>
+    {};
+    namespace detail
+    {
+        template<typename T, typename Void >
+        struct is_aggregate_
+          : is_pod<T>
+        {};
+        template<typename Tag, typename Args, long N>
+        struct is_aggregate_<proto::expr<Tag, Args, N>, void>
+          : mpl::true_
+        {};
+        template<typename Tag, typename Args, long N>
+        struct is_aggregate_<proto::basic_expr<Tag, Args, N>, void>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct is_aggregate_<T, typename T::proto_is_aggregate_>
+          : mpl::true_
+        {};
+    }
+    template<typename T>
+    struct is_aggregate
+      : proto::detail::is_aggregate_<T>
+    {};
+    template<typename T, typename Void >
+    struct is_expr
+      : mpl::false_
+    {};
+    template<typename T>
+    struct is_expr<T, typename T::proto_is_expr_>
+      : mpl::true_
+    {};
+    template<typename T>
+    struct is_expr<T &, void>
+      : is_expr<T>
+    {};
+    template<typename Expr>
+    struct tag_of
+    {
+        typedef typename Expr::proto_tag type;
+    };
+    template<typename Expr>
+    struct tag_of<Expr &>
+    {
+        typedef typename Expr::proto_tag type;
+    };
+    template<typename Expr>
+    struct arity_of
+      : Expr::proto_arity
+    {};
+    template<typename Expr>
+    struct arity_of<Expr &>
+      : Expr::proto_arity
+    {};
+    namespace result_of
+    {
+        template<typename T, typename Domain >
+        struct as_expr
+        {
+            typedef typename Domain::template as_expr<T>::result_type type;
+        };
+        template<typename T, typename Domain >
+        struct as_child
+        {
+            typedef typename Domain::template as_child<T>::result_type type;
+        };
+        template<typename Expr, typename N >
+        struct child
+          : child_c<Expr, N::value>
+        {};
+        template<typename Expr>
+        struct value
+        {
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 == Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_294;
+            typedef typename Expr::proto_child0 value_type;
+            typedef typename detail::term_traits<typename Expr::proto_child0>::value_type type;
+        };
+        template<typename Expr>
+        struct value<Expr &>
+        {
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 == Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_316;
+            typedef typename Expr::proto_child0 value_type;
+            typedef typename detail::term_traits<typename Expr::proto_child0>::reference type;
+        };
+        template<typename Expr>
+        struct value<Expr const &>
+        {
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 == Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_338;
+            typedef typename Expr::proto_child0 value_type;
+            typedef typename detail::term_traits<typename Expr::proto_child0>::const_reference type;
+        };
+        template<typename Expr>
+        struct left
+          : child_c<Expr, 0>
+        {};
+        template<typename Expr>
+        struct right
+          : child_c<Expr, 1>
+        {};
+    }
+    template<typename T>
+    struct terminal
+      : proto::transform<terminal<T>, int>
+    {
+        typedef proto::expr<proto::tag::terminal, term<T>, 0> type;
+        typedef proto::basic_expr<proto::tag::terminal, term<T>, 0> proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            inline __attribute__ ((always_inline))
+            typename impl::expr_param
+            operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+        typedef proto::tag::terminal proto_tag;
+        typedef T proto_child0;
+    };
+    template<typename T, typename U, typename V>
+    struct if_else_
+      : proto::transform<if_else_<T, U, V>, int>
+    {
+        typedef proto::expr<proto::tag::if_else_, list3<T, U, V>, 3> type;
+        typedef proto::basic_expr<proto::tag::if_else_, list3<T, U, V>, 3> proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::pass_through_impl<if_else_, Expr, State, Data>
+        {};
+        typedef proto::tag::if_else_ proto_tag;
+        typedef T proto_child0;
+        typedef U proto_child1;
+        typedef V proto_child2;
+    };
+    template<typename Tag, typename T>
+    struct nullary_expr
+      : proto::transform<nullary_expr<Tag, T>, int>
+    {
+        typedef proto::expr<Tag, term<T>, 0> type;
+        typedef proto::basic_expr<Tag, term<T>, 0> proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            inline __attribute__ ((always_inline))
+            typename impl::expr_param
+            operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+        typedef Tag proto_tag;
+        typedef T proto_child0;
+    };
+    template<typename Tag, typename T>
+    struct unary_expr
+      : proto::transform<unary_expr<Tag, T>, int>
+    {
+        typedef proto::expr<Tag, list1<T>, 1> type;
+        typedef proto::basic_expr<Tag, list1<T>, 1> proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::pass_through_impl<unary_expr, Expr, State, Data>
+        {};
+        typedef Tag proto_tag;
+        typedef T proto_child0;
+    };
+    template<typename Tag, typename T, typename U>
+    struct binary_expr
+      : proto::transform<binary_expr<Tag, T, U>, int>
+    {
+        typedef proto::expr<Tag, list2<T, U>, 2> type;
+        typedef proto::basic_expr<Tag, list2<T, U>, 2> proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::pass_through_impl<binary_expr, Expr, State, Data>
+        {};
+        typedef Tag proto_tag;
+        typedef T proto_child0;
+        typedef U proto_child1;
+    };
+    template<typename T> struct unary_plus : proto::transform<unary_plus<T>, int> { typedef proto::expr<proto::tag::unary_plus, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::unary_plus, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<unary_plus, Expr, State, Data> {}; typedef proto::tag::unary_plus proto_tag; typedef T proto_child0; };
+    template<typename T> struct negate : proto::transform<negate<T>, int> { typedef proto::expr<proto::tag::negate, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::negate, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<negate, Expr, State, Data> {}; typedef proto::tag::negate proto_tag; typedef T proto_child0; };
+    template<typename T> struct dereference : proto::transform<dereference<T>, int> { typedef proto::expr<proto::tag::dereference, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::dereference, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<dereference, Expr, State, Data> {}; typedef proto::tag::dereference proto_tag; typedef T proto_child0; };
+    template<typename T> struct complement : proto::transform<complement<T>, int> { typedef proto::expr<proto::tag::complement, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::complement, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<complement, Expr, State, Data> {}; typedef proto::tag::complement proto_tag; typedef T proto_child0; };
+    template<typename T> struct address_of : proto::transform<address_of<T>, int> { typedef proto::expr<proto::tag::address_of, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::address_of, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<address_of, Expr, State, Data> {}; typedef proto::tag::address_of proto_tag; typedef T proto_child0; };
+    template<typename T> struct logical_not : proto::transform<logical_not<T>, int> { typedef proto::expr<proto::tag::logical_not, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::logical_not, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<logical_not, Expr, State, Data> {}; typedef proto::tag::logical_not proto_tag; typedef T proto_child0; };
+    template<typename T> struct pre_inc : proto::transform<pre_inc<T>, int> { typedef proto::expr<proto::tag::pre_inc, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::pre_inc, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<pre_inc, Expr, State, Data> {}; typedef proto::tag::pre_inc proto_tag; typedef T proto_child0; };
+    template<typename T> struct pre_dec : proto::transform<pre_dec<T>, int> { typedef proto::expr<proto::tag::pre_dec, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::pre_dec, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<pre_dec, Expr, State, Data> {}; typedef proto::tag::pre_dec proto_tag; typedef T proto_child0; };
+    template<typename T> struct post_inc : proto::transform<post_inc<T>, int> { typedef proto::expr<proto::tag::post_inc, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::post_inc, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<post_inc, Expr, State, Data> {}; typedef proto::tag::post_inc proto_tag; typedef T proto_child0; };
+    template<typename T> struct post_dec : proto::transform<post_dec<T>, int> { typedef proto::expr<proto::tag::post_dec, list1<T>, 1> type; typedef proto::basic_expr<proto::tag::post_dec, list1<T>, 1> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<post_dec, Expr, State, Data> {}; typedef proto::tag::post_dec proto_tag; typedef T proto_child0; };
+    template<typename T, typename U> struct shift_left : proto::transform<shift_left<T, U>, int> { typedef proto::expr<proto::tag::shift_left, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::shift_left, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<shift_left, Expr, State, Data> {}; typedef proto::tag::shift_left proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct shift_right : proto::transform<shift_right<T, U>, int> { typedef proto::expr<proto::tag::shift_right, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::shift_right, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<shift_right, Expr, State, Data> {}; typedef proto::tag::shift_right proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct multiplies : proto::transform<multiplies<T, U>, int> { typedef proto::expr<proto::tag::multiplies, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::multiplies, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<multiplies, Expr, State, Data> {}; typedef proto::tag::multiplies proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct divides : proto::transform<divides<T, U>, int> { typedef proto::expr<proto::tag::divides, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::divides, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<divides, Expr, State, Data> {}; typedef proto::tag::divides proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct modulus : proto::transform<modulus<T, U>, int> { typedef proto::expr<proto::tag::modulus, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::modulus, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<modulus, Expr, State, Data> {}; typedef proto::tag::modulus proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct plus : proto::transform<plus<T, U>, int> { typedef proto::expr<proto::tag::plus, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::plus, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<plus, Expr, State, Data> {}; typedef proto::tag::plus proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct minus : proto::transform<minus<T, U>, int> { typedef proto::expr<proto::tag::minus, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::minus, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<minus, Expr, State, Data> {}; typedef proto::tag::minus proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct less : proto::transform<less<T, U>, int> { typedef proto::expr<proto::tag::less, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::less, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<less, Expr, State, Data> {}; typedef proto::tag::less proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct greater : proto::transform<greater<T, U>, int> { typedef proto::expr<proto::tag::greater, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::greater, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<greater, Expr, State, Data> {}; typedef proto::tag::greater proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct less_equal : proto::transform<less_equal<T, U>, int> { typedef proto::expr<proto::tag::less_equal, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::less_equal, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<less_equal, Expr, State, Data> {}; typedef proto::tag::less_equal proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct greater_equal : proto::transform<greater_equal<T, U>, int> { typedef proto::expr<proto::tag::greater_equal, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::greater_equal, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<greater_equal, Expr, State, Data> {}; typedef proto::tag::greater_equal proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct equal_to : proto::transform<equal_to<T, U>, int> { typedef proto::expr<proto::tag::equal_to, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::equal_to, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<equal_to, Expr, State, Data> {}; typedef proto::tag::equal_to proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct not_equal_to : proto::transform<not_equal_to<T, U>, int> { typedef proto::expr<proto::tag::not_equal_to, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::not_equal_to, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<not_equal_to, Expr, State, Data> {}; typedef proto::tag::not_equal_to proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct logical_or : proto::transform<logical_or<T, U>, int> { typedef proto::expr<proto::tag::logical_or, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::logical_or, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<logical_or, Expr, State, Data> {}; typedef proto::tag::logical_or proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct logical_and : proto::transform<logical_and<T, U>, int> { typedef proto::expr<proto::tag::logical_and, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::logical_and, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<logical_and, Expr, State, Data> {}; typedef proto::tag::logical_and proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_or : proto::transform<bitwise_or<T, U>, int> { typedef proto::expr<proto::tag::bitwise_or, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_or, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_or, Expr, State, Data> {}; typedef proto::tag::bitwise_or proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_and : proto::transform<bitwise_and<T, U>, int> { typedef proto::expr<proto::tag::bitwise_and, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_and, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_and, Expr, State, Data> {}; typedef proto::tag::bitwise_and proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_xor : proto::transform<bitwise_xor<T, U>, int> { typedef proto::expr<proto::tag::bitwise_xor, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_xor, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_xor, Expr, State, Data> {}; typedef proto::tag::bitwise_xor proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct comma : proto::transform<comma<T, U>, int> { typedef proto::expr<proto::tag::comma, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::comma, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<comma, Expr, State, Data> {}; typedef proto::tag::comma proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct mem_ptr : proto::transform<mem_ptr<T, U>, int> { typedef proto::expr<proto::tag::mem_ptr, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::mem_ptr, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<mem_ptr, Expr, State, Data> {}; typedef proto::tag::mem_ptr proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct assign : proto::transform<assign<T, U>, int> { typedef proto::expr<proto::tag::assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<assign, Expr, State, Data> {}; typedef proto::tag::assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct shift_left_assign : proto::transform<shift_left_assign<T, U>, int> { typedef proto::expr<proto::tag::shift_left_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::shift_left_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<shift_left_assign, Expr, State, Data> {}; typedef proto::tag::shift_left_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct shift_right_assign : proto::transform<shift_right_assign<T, U>, int> { typedef proto::expr<proto::tag::shift_right_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::shift_right_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<shift_right_assign, Expr, State, Data> {}; typedef proto::tag::shift_right_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct multiplies_assign : proto::transform<multiplies_assign<T, U>, int> { typedef proto::expr<proto::tag::multiplies_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::multiplies_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<multiplies_assign, Expr, State, Data> {}; typedef proto::tag::multiplies_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct divides_assign : proto::transform<divides_assign<T, U>, int> { typedef proto::expr<proto::tag::divides_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::divides_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<divides_assign, Expr, State, Data> {}; typedef proto::tag::divides_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct modulus_assign : proto::transform<modulus_assign<T, U>, int> { typedef proto::expr<proto::tag::modulus_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::modulus_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<modulus_assign, Expr, State, Data> {}; typedef proto::tag::modulus_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct plus_assign : proto::transform<plus_assign<T, U>, int> { typedef proto::expr<proto::tag::plus_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::plus_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<plus_assign, Expr, State, Data> {}; typedef proto::tag::plus_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct minus_assign : proto::transform<minus_assign<T, U>, int> { typedef proto::expr<proto::tag::minus_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::minus_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<minus_assign, Expr, State, Data> {}; typedef proto::tag::minus_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_or_assign : proto::transform<bitwise_or_assign<T, U>, int> { typedef proto::expr<proto::tag::bitwise_or_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_or_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_or_assign, Expr, State, Data> {}; typedef proto::tag::bitwise_or_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_and_assign : proto::transform<bitwise_and_assign<T, U>, int> { typedef proto::expr<proto::tag::bitwise_and_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_and_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_and_assign, Expr, State, Data> {}; typedef proto::tag::bitwise_and_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct bitwise_xor_assign : proto::transform<bitwise_xor_assign<T, U>, int> { typedef proto::expr<proto::tag::bitwise_xor_assign, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::bitwise_xor_assign, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<bitwise_xor_assign, Expr, State, Data> {}; typedef proto::tag::bitwise_xor_assign proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct subscript : proto::transform<subscript<T, U>, int> { typedef proto::expr<proto::tag::subscript, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::subscript, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<subscript, Expr, State, Data> {}; typedef proto::tag::subscript proto_tag; typedef T proto_child0; typedef U proto_child1; };
+    template<typename T, typename U> struct member : proto::transform<member<T, U>, int> { typedef proto::expr<proto::tag::member, list2<T, U>, 2> type; typedef proto::basic_expr<proto::tag::member, list2<T, U>, 2> proto_grammar; template<typename Expr, typename State, typename Data> struct impl : detail::pass_through_impl<member, Expr, State, Data> {}; typedef proto::tag::member proto_tag; typedef T proto_child0; typedef U proto_child1; };
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 0>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_20;
+                typedef typename Expr::proto_child0 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child0>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 0>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_35;
+                typedef typename Expr::proto_child0 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child0>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child0;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 0>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_57;
+                typedef typename Expr::proto_child0 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child0>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child0;
+                }
+            };
+        }
+        template<typename A0>
+        struct function
+        <
+            A0
+            , void , void , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0
+                    , void , void , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list1<A0>, 1> type;
+            typedef proto::basic_expr<proto::tag::function, list1<A0>, 1> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0;
+            typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
+        };
+        template<typename Tag , typename A0>
+        struct nary_expr
+        <
+            Tag
+            , A0
+            , void , void , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0
+                    , void , void , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list1<A0>, 1> type;
+            typedef proto::basic_expr<Tag, list1<A0>, 1> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0;
+            typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename> class T
+              , typename A0
+            >
+            struct is_callable_<T<A0> , 1>
+              : is_same<A0, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 1>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_162;
+                typedef typename Expr::proto_child1 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child1>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 1>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_177;
+                typedef typename Expr::proto_child1 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child1>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child1;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 1>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_199;
+                typedef typename Expr::proto_child1 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child1>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child1;
+                }
+            };
+        }
+        template<typename A0 , typename A1>
+        struct function
+        <
+            A0 , A1
+            , void , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1
+                    , void , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list2<A0 , A1>, 2> type;
+            typedef proto::basic_expr<proto::tag::function, list2<A0 , A1>, 2> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1;
+            typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1
+            , void , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1
+                    , void , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list2<A0 , A1>, 2> type;
+            typedef proto::basic_expr<Tag, list2<A0 , A1>, 2> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1;
+            typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename> class T
+              , typename A0 , typename A1
+            >
+            struct is_callable_<T<A0 , A1> , 2>
+              : is_same<A1, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 2>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_304;
+                typedef typename Expr::proto_child2 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child2>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 2>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_319;
+                typedef typename Expr::proto_child2 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child2>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child2;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 2>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_341;
+                typedef typename Expr::proto_child2 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child2>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child2;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2>
+        struct function
+        <
+            A0 , A1 , A2
+            , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2
+                    , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list3<A0 , A1 , A2>, 3> type;
+            typedef proto::basic_expr<proto::tag::function, list3<A0 , A1 , A2>, 3> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
+            typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2
+            , void , void , void , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2
+                    , void , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list3<A0 , A1 , A2>, 3> type;
+            typedef proto::basic_expr<Tag, list3<A0 , A1 , A2>, 3> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
+            typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2
+            >
+            struct is_callable_<T<A0 , A1 , A2> , 3>
+              : is_same<A2, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 3>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_446;
+                typedef typename Expr::proto_child3 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child3>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 3>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_461;
+                typedef typename Expr::proto_child3 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child3>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child3;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 3>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_483;
+                typedef typename Expr::proto_child3 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child3>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child3;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        struct function
+        <
+            A0 , A1 , A2 , A3
+            , void , void , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3
+                    , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> type;
+            typedef proto::basic_expr<proto::tag::function, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
+            typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3
+            , void , void , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3
+                    , void , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list4<A0 , A1 , A2 , A3>, 4> type;
+            typedef proto::basic_expr<Tag, list4<A0 , A1 , A2 , A3>, 4> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
+            typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3> , 4>
+              : is_same<A3, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 4>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_588;
+                typedef typename Expr::proto_child4 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child4>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 4>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_603;
+                typedef typename Expr::proto_child4 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child4>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child4;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 4>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_625;
+                typedef typename Expr::proto_child4 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child4>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child4;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct function
+        <
+            A0 , A1 , A2 , A3 , A4
+            , void , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4
+                    , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
+            typedef proto::basic_expr<proto::tag::function, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
+            typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3 , A4
+            , void , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4
+                    , void , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> type;
+            typedef proto::basic_expr<Tag, list5<A0 , A1 , A2 , A3 , A4>, 5> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
+            typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4> , 5>
+              : is_same<A4, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 5>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_730;
+                typedef typename Expr::proto_child5 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child5>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 5>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_745;
+                typedef typename Expr::proto_child5 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child5>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child5;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 5>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_767;
+                typedef typename Expr::proto_child5 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child5>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child5;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct function
+        <
+            A0 , A1 , A2 , A3 , A4 , A5
+            , void , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4 , A5
+                    , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
+            typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
+            typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3 , A4 , A5
+            , void , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4 , A5
+                    , void , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
+            typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
+            typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> , 6>
+              : is_same<A5, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 6>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_872;
+                typedef typename Expr::proto_child6 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 6>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_887;
+                typedef typename Expr::proto_child6 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child6;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 6>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_909;
+                typedef typename Expr::proto_child6 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child6;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct function
+        <
+            A0 , A1 , A2 , A3 , A4 , A5 , A6
+            , void , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
+            typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
+            typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6
+            , void , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    , void , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
+            typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
+            typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> , 7>
+              : is_same<A6, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 7>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1014;
+                typedef typename Expr::proto_child7 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child7>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 7>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1029;
+                typedef typename Expr::proto_child7 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child7>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child7;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 7>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1051;
+                typedef typename Expr::proto_child7 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child7>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child7;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct function
+        <
+            A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+            , void , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
+            typedef proto::basic_expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
+            typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+            , void , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    , void , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
+            typedef proto::basic_expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
+            typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> , 8>
+              : is_same<A7, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 8>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1156;
+                typedef typename Expr::proto_child8 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child8>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 8>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1171;
+                typedef typename Expr::proto_child8 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child8>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child8;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 8>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1193;
+                typedef typename Expr::proto_child8 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child8>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child8;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct function
+        <
+            A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+            , void
+        >
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
+            typedef proto::basic_expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
+            typedef detail::if_vararg<A8> proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct nary_expr
+        <
+            Tag
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+            , void
+        >
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    , void
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
+            typedef proto::basic_expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
+            typedef detail::if_vararg<A8> proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> , 9>
+              : is_same<A8, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 9>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1298;
+                typedef typename Expr::proto_child9 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child9>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 9>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1313;
+                typedef typename Expr::proto_child9 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child9>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child9;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 9>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1335;
+                typedef typename Expr::proto_child9 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child9>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child9;
+                }
+            };
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct function
+          : proto::transform<
+                function<
+                    A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
+            typedef proto::basic_expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, Expr, State, Data>
+            {};
+            typedef proto::tag::function proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
+        };
+        template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct nary_expr
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
+            typedef proto::basic_expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, Expr, State, Data>
+            {};
+            typedef Tag proto_tag;
+            typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
+        };
+        namespace detail
+        {
+            template<
+                template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+              , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+            >
+            struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> , 10>
+              : is_same<A9, callable>
+            {};
+        }
+        namespace result_of
+        {
+            template<typename Expr>
+            struct child_c<Expr, 10>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1431;
+                typedef typename Expr::proto_child10 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child10>::value_type type;
+            };
+            template<typename Expr>
+            struct child_c<Expr &, 10>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1446;
+                typedef typename Expr::proto_child10 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child10>::reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr &e)
+                {
+                    return e.proto_base().child10;
+                }
+            };
+            template<typename Expr>
+            struct child_c<Expr const &, 10>
+            {
+                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((0 != Expr::proto_arity_c) == 0 ? false : true) >)> boost_static_assert_typedef_1468;
+                typedef typename Expr::proto_child10 value_type;
+                typedef typename detail::expr_traits<typename Expr::proto_child10>::const_reference type;
+                inline __attribute__ ((always_inline))
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().child10;
+                }
+            };
+        }
+    namespace functional
+    {
+        template<typename Domain >
+        struct as_expr
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename T>
+            struct result<This(T)>
+            {
+                typedef typename Domain::template as_expr<T>::result_type type;
+            };
+            template<typename This, typename T>
+            struct result<This(T &)>
+            {
+                typedef typename Domain::template as_expr<T>::result_type type;
+            };
+            template<typename T>
+            inline __attribute__ ((always_inline))
+            typename add_const<typename result<as_expr(T &)>::type>::type
+            operator ()(T &t) const
+            {
+                return typename Domain::template as_expr<T>()(t);
+            }
+            template<typename T>
+            inline __attribute__ ((always_inline))
+            typename add_const<typename result<as_expr(T const &)>::type>::type
+            operator ()(T const &t) const
+            {
+                return typename Domain::template as_expr<T const>()(t);
+            }
+        };
+        template<typename Domain >
+        struct as_child
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename T>
+            struct result<This(T)>
+            {
+                typedef typename Domain::template as_child<T>::result_type type;
+            };
+            template<typename This, typename T>
+            struct result<This(T &)>
+            {
+                typedef typename Domain::template as_child<T>::result_type type;
+            };
+            template<typename T>
+            inline __attribute__ ((always_inline))
+            typename add_const<typename result<as_child(T &)>::type>::type
+            operator ()(T &t) const
+            {
+                return typename Domain::template as_child<T>()(t);
+            }
+            template<typename T>
+            inline __attribute__ ((always_inline))
+            typename add_const<typename result<as_child(T const &)>::type>::type
+            operator ()(T const &t) const
+            {
+                return typename Domain::template as_child<T const>()(t);
+            }
+        };
+        template<long N>
+        struct child_c
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef typename result_of::child_c<Expr, N>::type type;
+            };
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::child_c<Expr &, N>::type
+            operator ()(Expr &e) const
+            {
+                return result_of::child_c<Expr &, N>::call(e);
+            }
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::child_c<Expr const &, N>::type
+            operator ()(Expr const &e) const
+            {
+                return result_of::child_c<Expr const &, N>::call(e);
+            }
+        };
+        template<typename N >
+        struct child
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef typename result_of::child<Expr, N>::type type;
+            };
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::child<Expr &, N>::type
+            operator ()(Expr &e) const
+            {
+                return result_of::child<Expr &, N>::call(e);
+            }
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::child<Expr const &, N>::type
+            operator ()(Expr const &e) const
+            {
+                return result_of::child<Expr const &, N>::call(e);
+            }
+        };
+        struct value
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef typename result_of::value<Expr>::type type;
+            };
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::value<Expr &>::type
+            operator ()(Expr &e) const
+            {
+                return e.proto_base().child0;
+            }
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::value<Expr const &>::type
+            operator ()(Expr const &e) const
+            {
+                return e.proto_base().child0;
+            }
+        };
+        struct left
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef typename result_of::left<Expr>::type type;
+            };
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::left<Expr &>::type
+            operator ()(Expr &e) const
+            {
+                return e.proto_base().child0;
+            }
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::left<Expr const &>::type
+            operator ()(Expr const &e) const
+            {
+                return e.proto_base().child0;
+            }
+        };
+        struct right
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef typename result_of::right<Expr>::type type;
+            };
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::right<Expr &>::type
+            operator ()(Expr &e) const
+            {
+                return e.proto_base().child1;
+            }
+            template<typename Expr>
+            inline __attribute__ ((always_inline))
+            typename result_of::right<Expr const &>::type
+            operator ()(Expr const &e) const
+            {
+                return e.proto_base().child1;
+            }
+        };
+    }
+    template<typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_expr<T, default_domain>::type>::type
+    as_expr(T &t )
+    {
+        return default_domain::as_expr<T>()(t);
+    }
+    template<typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_expr<T const, default_domain>::type>::type
+    as_expr(T const &t)
+    {
+        return default_domain::as_expr<T const>()(t);
+    }
+    template<typename Domain, typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_expr<T, Domain>::type>::type
+    as_expr(T &t )
+    {
+        return typename Domain::template as_expr<T>()(t);
+    }
+    template<typename Domain, typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_expr<T const, Domain>::type>::type
+    as_expr(T const &t)
+    {
+        return typename Domain::template as_expr<T const>()(t);
+    }
+    template<typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_child<T, default_domain>::type>::type
+    as_child(T &t )
+    {
+        return default_domain::as_child<T>()(t);
+    }
+    template<typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_child<T const, default_domain>::type>::type
+    as_child(T const &t)
+    {
+        return default_domain::as_child<T const>()(t);
+    }
+    template<typename Domain, typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_child<T, Domain>::type>::type
+    as_child(T &t )
+    {
+        return typename Domain::template as_child<T>()(t);
+    }
+    template<typename Domain, typename T>
+    inline __attribute__ ((always_inline))
+    typename add_const<typename result_of::as_child<T const, Domain>::type>::type
+    as_child(T const &t)
+    {
+        return typename Domain::template as_child<T const>()(t);
+    }
+    template<typename N, typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::child<Expr &, N>::type
+    child(Expr &e )
+    {
+        return result_of::child<Expr &, N>::call(e);
+    }
+    template<typename N, typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::child<Expr const &, N>::type
+    child(Expr const &e)
+    {
+        return result_of::child<Expr const &, N>::call(e);
+    }
+    template<typename Expr2>
+    inline __attribute__ ((always_inline))
+    typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::reference
+    child(Expr2 &expr2 )
+    {
+        return expr2.proto_base().child0;
+    }
+    template<typename Expr2>
+    inline __attribute__ ((always_inline))
+    typename detail::expr_traits<typename Expr2::proto_base_expr::proto_child0>::const_reference
+    child(Expr2 const &expr2)
+    {
+        return expr2.proto_base().child0;
+    }
+    template<long N, typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::child_c<Expr &, N>::type
+    child_c(Expr &e )
+    {
+        return result_of::child_c<Expr &, N>::call(e);
+    }
+    template<long N, typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::child_c<Expr const &, N>::type
+    child_c(Expr const &e)
+    {
+        return result_of::child_c<Expr const &, N>::call(e);
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::value<Expr &>::type
+    value(Expr &e )
+    {
+        return e.proto_base().child0;
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::value<Expr const &>::type
+    value(Expr const &e)
+    {
+        return e.proto_base().child0;
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::left<Expr &>::type
+    left(Expr &e )
+    {
+        return e.proto_base().child0;
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::left<Expr const &>::type
+    left(Expr const &e)
+    {
+        return e.proto_base().child0;
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::right<Expr &>::type
+    right(Expr &e )
+    {
+        return e.proto_base().child1;
+    }
+    template<typename Expr>
+    inline __attribute__ ((always_inline))
+    typename result_of::right<Expr const &>::type
+    right(Expr const &e)
+    {
+        return e.proto_base().child1;
+    }
+    template<typename Domain>
+    struct is_callable<functional::as_expr<Domain> >
+      : mpl::true_
+    {};
+    template<typename Domain>
+    struct is_callable<functional::as_child<Domain> >
+      : mpl::true_
+    {};
+    template<long N>
+    struct is_callable<functional::child_c<N> >
+      : mpl::true_
+    {};
+    template<typename N>
+    struct is_callable<functional::child<N> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        struct not_a_valid_type
+        {
+        private:
+            not_a_valid_type()
+            {}
+        };
+        template<typename Tag, typename Arg>
+        struct address_of_hack
+        {
+            typedef not_a_valid_type type;
+        };
+        template<typename Expr>
+        struct address_of_hack<proto::tag::address_of, Expr &>
+        {
+            typedef Expr *type;
+        };
+        template<typename T, typename Expr, typename Arg0>
+        inline __attribute__ ((always_inline))
+        Expr make_terminal(T &t, Expr *, proto::term<Arg0> *)
+        {
+            Expr that = {t};
+            return that;
+        }
+        template<typename T, typename Expr, typename Arg0, std::size_t N>
+        inline __attribute__ ((always_inline))
+        Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *)
+        {
+            Expr that;
+            for(std::size_t i = 0; i < N; ++i)
+            {
+                that.child0[i] = t[i];
+            }
+            return that;
+        }
+        template<typename T, typename Expr, typename Arg0, std::size_t N>
+        inline __attribute__ ((always_inline))
+        Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *)
+        {
+            Expr that;
+            for(std::size_t i = 0; i < N; ++i)
+            {
+                that.child0[i] = t[i];
+            }
+            return that;
+        }
+        template<typename T, typename U>
+        struct same_cv
+        {
+            typedef U type;
+        };
+        template<typename T, typename U>
+        struct same_cv<T const, U>
+        {
+            typedef U const type;
+        };
+    }
+    namespace result_of
+    {
+        template<typename Sig, typename This, typename Domain>
+        struct funop;
+    template<typename Expr, typename Domain >
+    struct funop0
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list1<
+                Expr &
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+        )
+        {
+            type that = {
+                e
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename This, typename Domain>
+    struct funop<Expr(), This, Domain>
+      : funop0<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0>
+    struct funop1
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list2<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0, typename This, typename Domain>
+    struct funop<Expr(A0), This, Domain>
+      : funop1<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1>
+    struct funop2
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list3<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1, typename This, typename Domain>
+    struct funop<Expr(A0 , A1), This, Domain>
+      : funop2<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2>
+    struct funop3
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list4<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2), This, Domain>
+      : funop3<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
+    struct funop4
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list5<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3), This, Domain>
+      : funop4<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct funop5
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list6<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain>
+      : funop5<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct funop6
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list7<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain>
+      : funop6<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct funop7
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list8<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain>
+      : funop7<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct funop8
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list9<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain>
+      : funop8<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
+        >
+    {};
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct funop9
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list10<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type
+            >
+        >::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8)
+            };
+            return that;
+        }
+    };
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain>
+      : funop9<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
+        >
+    {};
+    }
+    namespace exprns_
+    {
+    template<typename Tag, typename Arg0>
+    struct basic_expr<Tag, term<Arg0>, 0>
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 0;
+        typedef mpl::long_<0 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef term<Arg0> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0>
+    struct basic_expr<Tag, list1<Arg0>, 1 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 1;
+        typedef mpl::long_<1 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list1<Arg0> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0)
+        {
+            basic_expr that = {a0};
+            return that;
+        }
+        typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        operator address_of_hack_type_() const
+        {
+            return boost::addressof(this->child0);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1>
+    struct basic_expr<Tag, list2<Arg0 , Arg1>, 2 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 2;
+        typedef mpl::long_<2 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list2<Arg0 , Arg1> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
+        typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1)
+        {
+            basic_expr that = {a0 , a1};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
+    struct basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 3;
+        typedef mpl::long_<3 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list3<Arg0 , Arg1 , Arg2> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
+        typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
+        {
+            basic_expr that = {a0 , a1 , a2};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
+    struct basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 4;
+        typedef mpl::long_<4 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
+        typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
+    struct basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 5;
+        typedef mpl::long_<5 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
+        typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+    struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 6;
+        typedef mpl::long_<6 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+        typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+    struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 7;
+        typedef mpl::long_<7 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+        typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+    struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 8;
+        typedef mpl::long_<8 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+        typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+    struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 9;
+        typedef mpl::long_<9 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+        typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+    struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 10;
+        typedef mpl::long_<10 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+        inline __attribute__ ((always_inline))
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        inline __attribute__ ((always_inline))
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    template<typename Tag, typename Arg0>
+    struct expr<Tag, term<Arg0>, 0>
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 0;
+        typedef mpl::long_<0 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef term<Arg0> proto_args;
+        typedef basic_expr<Tag, proto_args, 0 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 &a0)
+        {
+            return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0)
+        {
+            return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a)
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a)
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr &>, 1> const
+        operator ()()
+        {
+            proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0)
+        {
+            return result_of::funop1<
+                expr
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1)
+        {
+            return result_of::funop2<
+                expr
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2)
+        {
+            return result_of::funop3<
+                expr
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
+        {
+            return result_of::funop4<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
+        {
+            return result_of::funop5<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+        {
+            return result_of::funop6<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+        {
+            return result_of::funop7<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+        {
+            return result_of::funop8<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+        {
+            return result_of::funop9<
+                expr
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0>
+    struct expr<Tag, list1<Arg0>, 1 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 1;
+        typedef mpl::long_<1 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list1<Arg0> proto_args;
+        typedef basic_expr<Tag, proto_args, 1 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0)
+        {
+            expr that = {a0};
+            return that;
+        }
+        typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        operator address_of_hack_type_() const
+        {
+            return boost::addressof(this->child0);
+        }
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1>
+    struct expr<Tag, list2<Arg0 , Arg1>, 2 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 2;
+        typedef mpl::long_<2 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list2<Arg0 , Arg1> proto_args;
+        typedef basic_expr<Tag, proto_args, 2 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
+        typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1)
+        {
+            expr that = {a0 , a1};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
+    struct expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 3;
+        typedef mpl::long_<3 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list3<Arg0 , Arg1 , Arg2> proto_args;
+        typedef basic_expr<Tag, proto_args, 3 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
+        typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
+        {
+            expr that = {a0 , a1 , a2};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
+    struct expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 4;
+        typedef mpl::long_<4 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
+        typedef basic_expr<Tag, proto_args, 4 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
+        typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
+        {
+            expr that = {a0 , a1 , a2 , a3};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
+    struct expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 5;
+        typedef mpl::long_<5 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
+        typedef basic_expr<Tag, proto_args, 5 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
+        typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+    struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 6;
+        typedef mpl::long_<6 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+        typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+        typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+    struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 7;
+        typedef mpl::long_<7 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+        typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+        typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+    struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 8;
+        typedef mpl::long_<8 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+        typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+        typedef void proto_child8; typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+    struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 9;
+        typedef mpl::long_<9 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+        typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+        typedef void proto_child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+    struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 10;
+        typedef mpl::long_<10 > proto_arity;
+        typedef expr proto_base_expr;
+        typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+        typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_;
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+        inline __attribute__ ((always_inline))
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+        inline __attribute__ ((always_inline))
+        expr &proto_base()
+        {
+            return *this;
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        inline __attribute__ ((always_inline))
+        static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
+        {
+            expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+            return that;
+        }
+        typedef detail::not_a_valid_type address_of_hack_type_;
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename A>
+        inline __attribute__ ((always_inline))
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+        inline __attribute__ ((always_inline))
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+        template<typename A0>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop1<
+            expr const
+          , default_domain , const A0
+        >::type const
+        operator ()(A0 const &a0) const
+        {
+            return result_of::funop1<
+                expr const
+              , default_domain , const A0
+            >::call(*this , a0);
+        }
+        template<typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop2<
+            expr const
+          , default_domain , const A0 , const A1
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1) const
+        {
+            return result_of::funop2<
+                expr const
+              , default_domain , const A0 , const A1
+            >::call(*this , a0 , a1);
+        }
+        template<typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop3<
+            expr const
+          , default_domain , const A0 , const A1 , const A2
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+        {
+            return result_of::funop3<
+                expr const
+              , default_domain , const A0 , const A1 , const A2
+            >::call(*this , a0 , a1 , a2);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop4<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+        {
+            return result_of::funop4<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3
+            >::call(*this , a0 , a1 , a2 , a3);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop5<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+        {
+            return result_of::funop5<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+            >::call(*this , a0 , a1 , a2 , a3 , a4);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop6<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+        {
+            return result_of::funop6<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop7<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+        {
+            return result_of::funop7<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop8<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+        {
+            return result_of::funop8<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        typename result_of::funop9<
+            expr const
+          , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >::type const
+        operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+        {
+            return result_of::funop9<
+                expr const
+              , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+            >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    };
+    }
+    template<typename Expr>
+    struct unexpr
+      : Expr
+    {
+        typedef int proto_is_expr_;
+        inline __attribute__ ((always_inline))
+        explicit unexpr(Expr const &e)
+          : Expr(e)
+        {}
+        using Expr::operator =;
+    };
+}}
+namespace boost { namespace mpl {
+struct nested_begin_end_tag;
+struct non_sequence_tag;
+template< typename Sequence > struct sequence_tag;
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct fusion_is_view
+    {
+        typedef typename T::is_view type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    namespace traits
+    {
+        template<typename T, typename Active = void>
+        struct tag_of;
+    }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct begin_impl;
+template< typename Tag > struct end_impl;
+template< typename Sequence > struct begin;
+template< typename Sequence > struct end;
+}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        struct from_sequence_convertible_type
+        {};
+    }
+    template <typename Sequence>
+    struct sequence_base
+    {
+        Sequence const&
+        derived() const
+        {
+            return static_cast<Sequence const&>(*this);
+        }
+        Sequence&
+        derived()
+        {
+            return static_cast<Sequence&>(*this);
+        }
+        operator detail::from_sequence_convertible_type()const
+        {
+            return detail::from_sequence_convertible_type();
+        }
+    };
+    struct fusion_sequence_tag;
+}}
+namespace boost { namespace mpl
+{
+    template<> struct begin_impl< boost::fusion::fusion_sequence_tag >;
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct and_impl
+    : false_
+{
+};
+template< typename T1, typename T2, typename T3, typename T4 >
+struct and_impl< true,T1,T2,T3,T4 >
+    : and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , true_
+        >
+{
+};
+template<>
+struct and_impl<
+          true
+        , true_, true_, true_, true_
+        >
+    : true_
+{
+};
+}
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = true_, typename T4 = true_, typename T5 = true_
+    >
+struct and_
+    : aux::and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+{
+};
+template<> struct and_<
+ na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename C = na
+    , typename F1 = na
+    , typename F2 = na
+    >
+struct eval_if
+{
+    typedef typename if_<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+};
+template<
+      bool C
+    , typename F1
+    , typename F2
+    >
+struct eval_if_c
+{
+    typedef typename if_c<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+};
+template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Sequence >
+struct begin_type
+{
+    typedef typename Sequence::begin type;
+};
+template< typename Sequence >
+struct end_type
+{
+    typedef typename Sequence::end type;
+};
+}
+template< typename Tag >
+struct begin_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::begin_type<Sequence>, void_>::type type;
+    };
+};
+template< typename Tag >
+struct end_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::end_type<Sequence>, void_>::type type;
+    };
+};
+template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
+template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };
+template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+namespace boost { namespace mpl { namespace aux {
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< bool has_tag_, bool has_begin_ >
+struct sequence_tag_impl
+{
+    template< typename Sequence > struct result2_;
+};
+template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
+template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };
+}
+template<
+      typename Sequence = na
+    >
+struct sequence_tag
+    : aux::sequence_tag_impl<
+          ::boost::mpl::aux::has_tag<Sequence>::value
+        , ::boost::mpl::aux::has_begin<Sequence>::value
+        >::template result2_<Sequence>
+{
+};
+template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct begin
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename begin_impl< tag_ >
+        ::template apply< Sequence >::type type;
+};
+template<
+      typename Sequence = na
+    >
+struct end
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename end_impl< tag_ >
+        ::template apply< Sequence >::type type;
+};
+template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
+template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    >
+struct identity
+{
+    typedef T type;
+};
+template<
+      typename T = na
+    >
+struct make_identity
+{
+    typedef identity<T> type;
+};
+template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
+template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    >
+struct is_sequence
+    : not_< is_same< typename begin<T>::type, void_ > >
+{
+};
+template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }
+}}
+namespace boost {
+template< typename T > struct is_array : public ::boost::integral_constant<bool,false> { public: };
+template< typename T, std::size_t N > struct is_array< T[N] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, std::size_t N > struct is_array< T const[N] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, std::size_t N > struct is_array< T volatile[N] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T, std::size_t N > struct is_array< T const volatile[N] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T > struct is_array< T[] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T > struct is_array< T const[] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T > struct is_array< T volatile[] > : public ::boost::integral_constant<bool,true> { public: };
+template< typename T > struct is_array< T const volatile[] > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct add_reference_rvalue_layer
+{
+    typedef T& type;
+};
+template <typename T>
+struct add_reference_impl
+{
+    typedef typename add_reference_rvalue_layer<T>::type type;
+};
+template< typename T > struct add_reference_impl<T&> { public: typedef T& type; };
+template<> struct add_reference_impl<void> { public: typedef void type; };
+template<> struct add_reference_impl<void const> { public: typedef void const type; };
+template<> struct add_reference_impl<void volatile> { public: typedef void volatile type; };
+template<> struct add_reference_impl<void const volatile> { public: typedef void const volatile type; };
+}
+template< typename T > struct add_reference { public: typedef typename boost::detail::add_reference_impl<T>::type type; };
+}
+namespace boost {
+namespace detail {
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+};
+template <typename T> struct checker
+{
+    static boost::type_traits::no_type _m_check(any_conversion ...);
+    static boost::type_traits::yes_type _m_check(T, int);
+};
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    static typename add_rvalue_reference<From>::type _m_from;
+    static bool const value = sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) )
+        == sizeof(::boost::type_traits::yes_type);
+};
+template <typename From, typename To>
+struct is_convertible_impl
+{
+    typedef typename add_reference<From>::type ref_type;
+    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value)
+         ;
+};
+template <bool trivial1, bool trivial2, bool abstract_target>
+struct is_convertible_impl_select
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef is_convertible_impl<From, To> type;
+   };
+};
+template <>
+struct is_convertible_impl_select<true, true, false>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef true_type type;
+   };
+};
+template <>
+struct is_convertible_impl_select<false, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+template <>
+struct is_convertible_impl_select<true, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+template <typename From, typename To>
+struct is_convertible_impl_dispatch_base
+{
+   typedef is_convertible_impl_select<
+      ::boost::is_arithmetic<From>::value,
+      ::boost::is_arithmetic<To>::value,
+      ::boost::is_abstract<To>::value
+   > selector;
+   typedef typename selector::template rebind<From, To> isc_binder;
+   typedef typename isc_binder::type type;
+};
+template <typename From, typename To>
+struct is_convertible_impl_dispatch
+   : public is_convertible_impl_dispatch_base<From, To>::type
+{};
+    template<> struct is_convertible_impl< void,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { public: static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { public: static const bool value = (true); };
+template< typename To > struct is_convertible_impl< void,To > { public: static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void > { public: static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void const,To > { public: static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void volatile,To > { public: static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void const volatile,To > { public: static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void const > { public: static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void volatile > { public: static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void const volatile > { public: static const bool value = (false); };
+}
+template< typename From, typename To > struct is_convertible : public ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { public: };
+}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct is_mpl_sequence
+        : mpl::and_<
+            mpl::not_<is_convertible<T, from_sequence_convertible_type> >
+          , mpl::is_sequence<T> >
+    {};
+}}}
+namespace boost
+{
+    template <typename T, std::size_t N>
+    class array;
+    namespace tuples
+    {
+        struct null_type;
+        template <
+            class T0, class T1, class T2, class T3, class T4,
+            class T5, class T6, class T7, class T8, class T9
+        >
+        class tuple;
+        template <class Head, class Tail>
+        struct cons;
+    }
+}
+namespace boost { namespace fusion
+{
+    struct non_fusion_tag;
+    struct mpl_sequence_tag;
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_fusion_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::fusion_tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template <typename Sequence, typename Active>
+        struct tag_of_impl
+          : mpl::if_<fusion::detail::is_mpl_sequence<Sequence>,
+              mpl::identity<mpl_sequence_tag>,
+              mpl::identity<non_fusion_tag> >::type
+        {};
+        template <typename Sequence>
+        struct tag_of_impl<
+            Sequence
+          , typename boost::enable_if<detail::has_fusion_tag<Sequence> >::type>
+        {
+            typedef typename Sequence::fusion_tag type;
+        };
+    }
+    namespace traits
+    {
+        template <typename Sequence, typename Active>
+        struct tag_of
+            : boost::fusion::detail::tag_of_impl<Sequence, Active>
+        {};
+    }
+    namespace detail
+    {
+        template<typename T>
+        struct tag_of
+            : traits::tag_of<typename remove_const<T>::type>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_view_impl
+        {
+            template <typename T>
+            struct apply
+                : detail::fusion_is_view<T>
+            {};
+        };
+        template <>
+        struct is_view_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::is_view {};
+        };
+        template <>
+        struct is_view_impl<boost_tuple_tag>;
+        template <>
+        struct is_view_impl<boost_array_tag>;
+        template <>
+        struct is_view_impl<mpl_sequence_tag>;
+        template <>
+        struct is_view_impl<std_pair_tag>;
+    }
+    namespace traits
+    {
+        template <typename T>
+        struct is_view :
+            extension::is_view_impl<typename fusion::detail::tag_of<T>::type>::
+                template apply<T>::type
+        {};
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct fusion_category_of
+    {
+        typedef typename T::category type;
+    };
+}}}
+namespace boost {
+namespace detail {
+template <typename B, typename D>
+struct is_base_and_derived_impl
+{
+    typedef typename remove_cv<B>::type ncvB;
+    typedef typename remove_cv<D>::type ncvD;
+    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
+};
+}
+template< typename Base, typename Derived > struct is_base_and_derived : public ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { public: };
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
+template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct is_class_impl
+{
+    static const bool value = __is_class(T);
+};
+}
+template< typename T > struct is_class : public ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { public: };
+}
+namespace boost {
+   namespace detail{
+      template <class B, class D>
+      struct is_base_of_imp
+      {
+          typedef typename remove_cv<B>::type ncvB;
+          typedef typename remove_cv<D>::type ncvD;
+          static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value)
+                                                                                                                                 ;
+      };
+   }
+template< typename Base, typename Derived > struct is_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { public: };
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
+template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost { namespace fusion
+{
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    struct incrementable_traversal_tag {};
+    struct single_pass_traversal_tag
+        : incrementable_traversal_tag {};
+    struct forward_traversal_tag
+        : single_pass_traversal_tag {};
+    struct bidirectional_traversal_tag
+        : forward_traversal_tag {};
+    struct random_access_traversal_tag
+        : bidirectional_traversal_tag {};
+    struct associative_tag {};
+    namespace extension
+    {
+        template<typename Tag>
+        struct category_of_impl
+        {
+            template<typename T>
+            struct apply : detail::fusion_category_of<T> {};
+        };
+        template <>
+        struct category_of_impl<boost_tuple_tag>;
+        template <>
+        struct category_of_impl<boost_array_tag>;
+        template <>
+        struct category_of_impl<mpl_sequence_tag>;
+        template <>
+        struct category_of_impl<std_pair_tag>;
+    }
+    namespace traits
+    {
+        template <typename T>
+        struct category_of
+            : extension::category_of_impl<typename fusion::detail::tag_of<T>::type>::
+                template apply<T>
+        {};
+        template <typename T>
+        struct is_associative
+            : is_base_of<
+                associative_tag
+              , typename category_of<T>::type>
+        {};
+        template <typename T>
+        struct is_incrementable
+            : is_base_of<
+                incrementable_traversal_tag
+              , typename category_of<T>::type>
+        {};
+        template <typename T>
+        struct is_single_pass
+            : is_base_of<
+                single_pass_traversal_tag
+              , typename category_of<T>::type>
+        {};
+        template <typename T>
+        struct is_forward
+            : is_base_of<
+                forward_traversal_tag
+              , typename category_of<T>::type>
+        {};
+        template <typename T>
+        struct is_bidirectional
+            : is_base_of<
+                bidirectional_traversal_tag
+              , typename category_of<T>::type>
+        {};
+        template <typename T>
+        struct is_random_access
+            : is_base_of<
+                random_access_traversal_tag
+              , typename category_of<T>::type>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_root {};
+    template <typename Iterator>
+    struct iterator_base : iterator_root
+    {
+        Iterator const&
+        cast() const
+        {
+            return static_cast<Iterator const&>(*this);
+        }
+        Iterator&
+        cast()
+        {
+            return static_cast<Iterator&>(*this);
+        }
+    };
+}}
+namespace boost {
+namespace detail{
+template <class T>
+struct is_const_rvalue_filter
+{
+   static const bool value = ::boost::detail::cv_traits_imp<T*>::is_const;
+};
+}
+template< typename T > struct is_const : public ::boost::integral_constant<bool,::boost::detail::is_const_rvalue_filter<T>::value> { public: };
+template< typename T > struct is_const< T& > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost { namespace fusion
+{
+    struct non_fusion_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename T>
+        struct is_sequence_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : is_convertible<Sequence, detail::from_sequence_convertible_type>
+            {};
+        };
+        template <>
+        struct is_sequence_impl<non_fusion_tag>
+        {
+            template <typename T>
+            struct apply : mpl::false_ {};
+        };
+        template <>
+        struct is_sequence_impl<boost_tuple_tag>;
+        template <>
+        struct is_sequence_impl<boost_array_tag>;
+        template <>
+        struct is_sequence_impl<mpl_sequence_tag>;
+        template <>
+        struct is_sequence_impl<std_pair_tag>;
+    }
+    namespace traits
+    {
+        template <typename T>
+        struct is_sequence
+          : extension::is_sequence_impl<
+                typename fusion::detail::tag_of<T>::type
+            >::template apply<T>
+        {};
+        template <typename Sequence, typename Enable = void>
+        struct is_native_fusion_sequence
+          : is_convertible<Sequence, detail::from_sequence_convertible_type>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+        template <typename Tag>
+        struct begin_impl;
+        template <typename Tag>
+        struct empty_impl;
+        template <typename Tag>
+        struct end_impl;
+        template <typename Tag>
+        struct has_key_impl;
+        template <typename Tag>
+        struct segments_impl;
+        template <typename Tag>
+        struct size_impl;
+        template <typename Tag>
+        struct value_at_impl;
+        template <typename Tag>
+        struct at_key_impl;
+        template <typename Tag>
+        struct value_at_key_impl;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct at;
+        template <typename Sequence, int N>
+        struct at_c;
+        template <typename Sequence>
+        struct back;
+        template <typename Sequence>
+        struct begin;
+        template <typename Sequence>
+        struct empty;
+        template <typename Sequence>
+        struct end;
+        template <typename Sequence>
+        struct front;
+        template <typename Sequence, typename Key>
+        struct has_key;
+        template <typename Sequence>
+        struct segments;
+        template <typename Sequence>
+        struct size;
+        template <typename Sequence, typename N>
+        struct value_at;
+        template <typename Sequence, int N>
+        struct value_at_c;
+        template <typename Sequence, typename Key>
+        struct at_key;
+        template <typename Sequence, typename N>
+        struct value_at_key;
+    }
+    template <typename N, typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at<Sequence, N>
+        >::type
+    at(Sequence& seq);
+    template <typename N, typename Sequence>
+    typename result_of::at<Sequence const, N>::type
+    at(Sequence const& seq);
+    template <int N, typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_c<Sequence, N>
+        >::type
+    at_c(Sequence& seq);
+    template <int N, typename Sequence>
+    typename result_of::at_c<Sequence const, N>::type
+    at_c(Sequence const& seq);
+    template <typename Sequence>
+    typename result_of::back<Sequence>::type
+    back(Sequence& seq);
+    template <typename Sequence>
+    typename result_of::back<Sequence const>::type
+    back(Sequence const& seq);
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence>
+        >::type const
+    begin(Sequence& seq);
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence const>
+        >::type const
+    begin(Sequence const& seq);
+    template <typename Sequence>
+    typename result_of::empty<Sequence>::type
+    empty(Sequence const&);
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence>
+        >::type const
+    end(Sequence& seq);
+    template <typename Sequence>
+    typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence const>
+        >::type const
+    end(Sequence const& seq);
+    template <typename Sequence>
+    typename result_of::front<Sequence>::type
+    front(Sequence& seq);
+    template <typename Sequence>
+    typename result_of::front<Sequence const>::type
+    front(Sequence const& seq);
+    template <typename Key, typename Sequence>
+    typename result_of::has_key<Sequence, Key>::type
+    has_key(Sequence const& seq);
+    template <typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segments<Sequence>
+        >::type
+    segments(Sequence& seq);
+    template <typename Sequence>
+    typename result_of::segments<Sequence const>::type
+    segments(Sequence const& seq);
+    template <typename Sequence>
+    typename result_of::size<Sequence>::type
+    size(Sequence const&);
+    template <typename Key, typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_key<Sequence, Key>
+        >::type
+    at_key(Sequence& seq);
+    template <typename Key, typename Sequence>
+    typename result_of::at_key<Sequence const, Key>::type
+    at_key(Sequence const& seq);
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct ref_result
+    {
+        typedef typename add_reference<typename T::type>::type type;
+    };
+    template <typename T>
+    struct cref_result
+    {
+        typedef typename
+            add_reference<
+                typename add_const<typename T::type>::type
+            >::type
+        type;
+    };
+    template <typename T>
+    struct call_param
+    {
+        typedef T const& type;
+    };
+    template <typename T>
+    struct call_param<T &>
+    {
+        typedef T& type;
+    };
+    template <typename T>
+    struct call_param<T const>
+    {
+        typedef T const& type;
+    };
+    template <typename T>
+    struct call_param<T volatile>
+    {
+        typedef T const& type;
+    };
+    template <typename T>
+    struct call_param<T const volatile>
+    {
+        typedef T const& type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    struct std_tuple_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl
+        {
+            template <typename Sequence, typename N>
+            struct apply;
+        };
+        template <>
+        struct at_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply : Sequence::template at<Sequence, N> {};
+        };
+        template <>
+        struct at_impl<boost_tuple_tag>;
+        template <>
+        struct at_impl<boost_array_tag>;
+        template <>
+        struct at_impl<mpl_sequence_tag>;
+        template <>
+        struct at_impl<std_pair_tag>;
+        template <>
+        struct at_impl<std_tuple_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct at
+            : extension::at_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+        template <typename Sequence, int N>
+        struct at_c
+            : at<Sequence, mpl::int_<N> >
+        {};
+    }
+    template <typename N, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at<Sequence, N>
+        >::type
+    at(Sequence& seq)
+    {
+        return result_of::at<Sequence, N>::call(seq);
+    }
+    template <typename N, typename Sequence>
+    inline typename result_of::at<Sequence const, N>::type
+    at(Sequence const& seq)
+    {
+        return result_of::at<Sequence const, N>::call(seq);
+    }
+    template <int N, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_c<Sequence, N>
+        >::type
+    at_c(Sequence& seq)
+    {
+        return fusion::at<mpl::int_<N> >(seq);
+    }
+    template <int N, typename Sequence>
+    inline typename result_of::at_c<Sequence const, N>::type
+    at_c(Sequence const& seq)
+    {
+        return fusion::at<mpl::int_<N> >(seq);
+    }
+}}
+namespace boost {
+struct blank;
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct empty_helper_t1 : public T
+{
+    empty_helper_t1();
+    int i[256];
+private:
+   empty_helper_t1(const empty_helper_t1&);
+   empty_helper_t1& operator=(const empty_helper_t1&);
+};
+struct empty_helper_t2 { int i[256]; };
+template <typename T, bool is_a_class = false>
+struct empty_helper
+{
+    static const bool value = false;
+};
+template <typename T>
+struct empty_helper<T, true>
+{
+    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2))
+         ;
+};
+template <typename T>
+struct is_empty_impl
+{
+    typedef typename remove_cv<T>::type cvt;
+    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , false >::value )
+              ;
+};
+template<> struct is_empty_impl< void > { public: static const bool value = (false); };
+template<> struct is_empty_impl< void const > { public: static const bool value = (false); };
+template<> struct is_empty_impl< void volatile > { public: static const bool value = (false); };
+template<> struct is_empty_impl< void const volatile > { public: static const bool value = (false); };
+}
+template< typename T > struct is_empty : public ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct has_trivial_ctor_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, ((__has_trivial_constructor(T) ) && ! ::boost::is_volatile<T>::value) >::value)
+                ;
+};
+}
+template< typename T > struct has_trivial_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { public: };
+template< typename T > struct has_trivial_default_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct has_trivial_copy_impl
+{
+   static const bool value = ((__has_trivial_copy(T) ) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value);
+};
+}
+template< typename T > struct has_trivial_copy : public ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { public: };
+template< typename T > struct has_trivial_copy_constructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { public: };
+template<> struct has_trivial_copy< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_copy_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct has_trivial_dtor_impl
+{
+   static const bool value = (__has_trivial_destructor(T) );
+};
+}
+template< typename T > struct has_trivial_destructor : public ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { public: };
+template<> struct has_trivial_destructor< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_destructor< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_destructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_destructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct is_stateless_impl
+{
+  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value)
+               ;
+};
+}
+template< typename T > struct is_stateless : public ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { public: };
+}
+namespace boost {
+struct blank
+{
+};
+template <>
+struct is_pod< blank >
+    : mpl::true_
+{
+};
+template <>
+struct is_empty< blank >
+    : mpl::true_
+{
+};
+template <>
+struct is_stateless< blank >
+    : mpl::true_
+{
+};
+inline bool operator==(const blank&, const blank&)
+{
+    return true;
+}
+inline bool operator<=(const blank&, const blank&)
+{
+    return true;
+}
+inline bool operator>=(const blank&, const blank&)
+{
+    return true;
+}
+inline bool operator!=(const blank&, const blank&)
+{
+    return false;
+}
+inline bool operator<(const blank&, const blank&)
+{
+    return false;
+}
+inline bool operator>(const blank&, const blank&)
+{
+    return false;
+}
+template < typename E , typename T >
+inline std::basic_ostream< E , T >& operator<<(
+      std::basic_ostream< E , T >& out
+    , const blank&
+    )
+{
+    return out;
+}
+}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct is_segmented_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : mpl::false_
+            {};
+        };
+        template <>
+        struct is_segmented_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::is_segmented {};
+        };
+        template <>
+        struct is_segmented_impl<iterator_range_tag>;
+    }
+    namespace traits
+    {
+        template <typename Sequence>
+        struct is_segmented
+          : extension::is_segmented_impl<typename traits::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    template <typename Car, typename Cdr = nil>
+    struct cons;
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Sequence, typename Stack>
+    struct segmented_end_impl
+    {
+        enum { mpl_assertion_in_line_35 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (traits::is_segmented<Sequence>))0, 1 ) ) ) };
+        typedef
+            typename result_of::end<
+                typename remove_reference<
+                    typename add_const<
+                        typename result_of::segments<Sequence>::type
+                    >::type
+                >::type
+            >::type
+        end_type;
+        typedef iterator_range<end_type, end_type> pair_type;
+        typedef cons<pair_type, Stack> type;
+        static type call(Sequence & seq, Stack stack)
+        {
+            end_type end = fusion::end(fusion::segments(seq));
+            return type(pair_type(end, end), stack);
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl
+        {
+            template <typename Iterator>
+            struct apply {};
+        };
+        template <>
+        struct next_impl<iterator_facade_tag>
+        {
+            template <typename Iterator>
+            struct apply : Iterator::template next<Iterator> {};
+        };
+        template <>
+        struct next_impl<boost_array_iterator_tag>;
+        template <>
+        struct next_impl<mpl_iterator_tag>;
+        template <>
+        struct next_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Iterator>
+        struct next
+            : extension::next_impl<typename detail::tag_of<Iterator>::type>::
+                template apply<Iterator>
+        {};
+    }
+    template <typename Iterator>
+    typename result_of::next<Iterator>::type const
+    next(Iterator const& i)
+    {
+        return result_of::next<Iterator>::call(i);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct prior_impl
+        {
+            template <typename Iterator>
+            struct apply {};
+        };
+        template <>
+        struct prior_impl<iterator_facade_tag>
+        {
+            template <typename Iterator>
+            struct apply : Iterator::template prior<Iterator> {};
+        };
+        template <>
+        struct prior_impl<boost_array_iterator_tag>;
+        template <>
+        struct prior_impl<mpl_iterator_tag>;
+        template <>
+        struct prior_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Iterator>
+        struct prior
+            : extension::prior_impl<typename detail::tag_of<Iterator>::type>::
+                template apply<Iterator>
+        {};
+    }
+    template <typename Iterator>
+    typename result_of::prior<Iterator>::type const
+    prior(Iterator const& i)
+    {
+        return result_of::prior<Iterator>::call(i);
+    }
+}}
+namespace boost { namespace fusion { namespace advance_detail
+{
+    template <typename Iterator, int N>
+    struct forward;
+    template <typename Iterator, int N>
+    struct next_forward
+    {
+        typedef typename
+            forward<
+                typename result_of::next<Iterator>::type
+              , N-1
+            >::type
+        type;
+    };
+    template <typename Iterator, int N>
+    struct forward
+    {
+        typedef typename
+            mpl::eval_if_c<
+                (N == 0)
+              , mpl::identity<Iterator>
+              , next_forward<Iterator, N>
+            >::type
+        type;
+        static type const&
+        call(type const& i)
+        {
+            return i;
+        }
+        template <typename I>
+        static type
+        call(I const& i)
+        {
+            return call(fusion::next(i));
+        }
+    };
+    template <typename Iterator, int N>
+    struct backward;
+    template <typename Iterator, int N>
+    struct next_backward
+    {
+        typedef typename
+            backward<
+                typename result_of::prior<Iterator>::type
+              , N+1
+            >::type
+        type;
+    };
+    template <typename Iterator, int N>
+    struct backward
+    {
+        typedef typename
+            mpl::eval_if_c<
+                (N == 0)
+              , mpl::identity<Iterator>
+              , next_backward<Iterator, N>
+            >::type
+        type;
+        static type const&
+        call(type const& i)
+        {
+            return i;
+        }
+        template <typename I>
+        static type
+        call(I const& i)
+        {
+            return call(fusion::prior(i));
+        }
+    };
+}}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    >
+struct next
+{
+    typedef typename T::next type;
+};
+template<
+      typename T = na
+    >
+struct prior
+{
+    typedef typename T::prior type;
+};
+template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
+template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_root;
+    template <typename T>
+    struct is_fusion_iterator : is_base_of<iterator_root, T> {};
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct equal_to_impl
+        {
+            template <typename I1, typename I2>
+            struct apply
+                : is_same<typename add_const<I1>::type, typename add_const<I2>::type>
+            {};
+        };
+        template <>
+        struct equal_to_impl<iterator_facade_tag>
+        {
+            template <typename It1, typename It2, typename Tag1, typename Tag2>
+            struct dispatch : mpl::false_ {};
+            template <typename It1, typename It2, typename Tag>
+            struct dispatch<It1, It2, Tag, Tag>
+              : It1::template equal_to<It1, It2>
+            {};
+            template<typename It1, typename It2>
+            struct apply : dispatch<It1, It2,
+                typename It1::fusion_tag, typename It2::fusion_tag>
+            {};
+        };
+        template <>
+        struct equal_to_impl<boost_array_iterator_tag>;
+        template <>
+        struct equal_to_impl<mpl_iterator_tag>;
+        template <>
+        struct equal_to_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename I1, typename I2>
+        struct equal_to
+            : extension::equal_to_impl<typename detail::tag_of<I1>::type>::
+                template apply<I1, I2>
+        {};
+    }
+    namespace iterator_operators
+    {
+        template <typename Iter1, typename Iter2>
+        inline typename
+        boost::enable_if<
+            mpl::and_<is_fusion_iterator<Iter1>, is_fusion_iterator<Iter2> >
+            , bool
+            >::type
+        operator==(Iter1 const&, Iter2 const&)
+        {
+            return result_of::equal_to<Iter1, Iter2>::value;
+        }
+        template <typename Iter1, typename Iter2>
+        inline typename
+        boost::enable_if<
+            mpl::and_<is_fusion_iterator<Iter1>, is_fusion_iterator<Iter2> >
+            , bool
+            >::type
+        operator!=(Iter1 const&, Iter2 const&)
+        {
+            return !result_of::equal_to<Iter1, Iter2>::value;
+        }
+    }
+    using iterator_operators::operator==;
+    using iterator_operators::operator!=;
+}}
+namespace boost { namespace fusion { namespace distance_detail
+{
+    template <typename First, typename Last>
+    struct linear_distance;
+    template <typename First, typename Last>
+    struct next_distance
+    {
+        typedef typename
+            mpl::next<
+                typename linear_distance<
+                    typename result_of::next<First>::type
+                  , Last
+                >::type
+            >::type
+        type;
+    };
+    template <typename First, typename Last>
+    struct linear_distance
+        : mpl::eval_if<
+            result_of::equal_to<First, Last>
+          , mpl::identity<mpl::int_<0> >
+          , next_distance<First, Last>
+        >::type
+    {
+        typedef typename
+            mpl::eval_if<
+                result_of::equal_to<First, Last>
+              , mpl::identity<mpl::int_<0> >
+              , next_distance<First, Last>
+            >::type
+        type;
+        static type
+        call(First const&, Last const&)
+        {
+            return type();
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    template <typename Derived, typename Category>
+    struct iterator_facade : iterator_base<Derived>
+    {
+        typedef iterator_facade_tag fusion_tag;
+        typedef Derived derived_type;
+        typedef Category category;
+        template <typename I1, typename I2>
+        struct equal_to
+            : is_same<
+                typename I1::derived_type
+              , typename I2::derived_type
+            >
+        {};
+        template <typename Iterator, typename N>
+        struct advance :
+            mpl::if_c<
+                (N::value > 0)
+              , advance_detail::forward<Iterator, N::value>
+              , advance_detail::backward<Iterator, N::value>
+            >::type
+        {
+            enum { mpl_assertion_in_line_46 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (traits::is_random_access<Iterator>))0, 1 ) ) ) };
+        };
+        template <typename First, typename Last>
+        struct distance :
+            distance_detail::linear_distance<First, Last>
+        {};
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl
+        {
+            template <typename Iterator>
+            struct apply {};
+        };
+        template <>
+        struct deref_impl<iterator_facade_tag>
+        {
+            template <typename Iterator>
+            struct apply : Iterator::template deref<Iterator> {};
+       };
+        template <>
+        struct deref_impl<boost_array_iterator_tag>;
+        template <>
+        struct deref_impl<mpl_iterator_tag>;
+        template <>
+        struct deref_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Iterator>
+        struct deref
+            : extension::deref_impl<typename detail::tag_of<Iterator>::type>::
+                template apply<Iterator>
+        {};
+    }
+    template <typename Iterator>
+    typename result_of::deref<Iterator>::type
+    deref(Iterator const& i)
+    {
+        typedef result_of::deref<Iterator> deref_meta;
+        return deref_meta::call(i);
+    }
+    template <typename Iterator>
+    typename result_of::deref<Iterator>::type
+    operator*(iterator_base<Iterator> const& i)
+    {
+        return fusion::deref(i.cast());
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    namespace extension
+    {
+        template <typename>
+        struct deref_data_impl;
+        template <>
+        struct deref_data_impl<iterator_facade_tag>
+        {
+            template <typename It>
+            struct apply
+              : It::template deref_data<It>
+            {};
+       };
+    }
+    namespace result_of
+    {
+        template <typename It>
+        struct deref_data
+          : extension::deref_data_impl<typename traits::tag_of<It>::type>::
+                template apply<It>
+        {};
+    }
+    template <typename It>
+    typename result_of::deref_data<It>::type
+    deref_data(It const& it)
+    {
+        return result_of::deref_data<It>::call(it);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    namespace extension
+    {
+        template <typename>
+        struct key_of_impl;
+        template <>
+        struct key_of_impl<iterator_facade_tag>
+        {
+            template <typename It>
+            struct apply
+              : It::template key_of<It>
+            {};
+        };
+    }
+    namespace result_of
+    {
+        template <typename It>
+        struct key_of
+          : extension::key_of_impl<typename traits::tag_of<It>::type>::
+                template apply<It>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl
+        {
+            template <typename Iterator>
+            struct apply {};
+        };
+        template <>
+        struct value_of_impl<iterator_facade_tag>
+        {
+            template <typename Iterator>
+            struct apply : Iterator::template value_of<Iterator> {};
+        };
+        template <>
+        struct value_of_impl<boost_array_iterator_tag>;
+        template <>
+        struct value_of_impl<mpl_iterator_tag>;
+        template <>
+        struct value_of_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Iterator>
+        struct value_of
+            : extension::value_of_impl<typename detail::tag_of<Iterator>::type>::
+                template apply<Iterator>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_facade_tag;
+    namespace extension
+    {
+        template <typename>
+        struct value_of_data_impl;
+        template <>
+        struct value_of_data_impl<iterator_facade_tag>
+        {
+            template <typename It>
+            struct apply
+              : It::template value_of_data<It>
+            {};
+        };
+    }
+    namespace result_of
+    {
+        template <typename It>
+        struct value_of_data
+          : extension::value_of_data_impl<typename traits::tag_of<It>::type>::
+                template apply<It>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    namespace detail
+    {
+        template <typename Stack1, typename Stack2>
+        struct segmented_equal_to
+          : mpl::and_<
+                segmented_equal_to<
+                    typename Stack1::cdr_type,
+                    typename Stack2::cdr_type
+                >
+              , result_of::equal_to<
+                    typename Stack1::car_type::begin_type,
+                    typename Stack2::car_type::begin_type
+                >
+            >
+        {};
+        template <>
+        struct segmented_equal_to<fusion::nil, fusion::nil>
+          : mpl::true_
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    namespace detail
+    {
+        template <typename Stack>
+        struct segmented_next_impl;
+    }
+    template <typename Context>
+    struct segmented_iterator
+      : iterator_facade<segmented_iterator<Context>, forward_traversal_tag>
+    {
+        explicit segmented_iterator(Context const& ctx)
+          : context(ctx)
+        {}
+        template <typename It>
+        struct deref
+        {
+            typedef
+                typename result_of::deref<
+                    typename It::context_type::car_type::begin_type
+                >::type
+            type;
+            static type call(It const& it)
+            {
+                return *it.context.car.first;
+            }
+        };
+        template <typename It>
+        struct deref_data
+        {
+            typedef
+                typename result_of::deref_data<
+                    typename It::context_type::car_type::begin_type
+                >::type
+            type;
+            static type call(It const& it)
+            {
+                return fusion::deref_data(it.context.car.first);
+            }
+        };
+        template <typename It>
+        struct key_of
+          : result_of::key_of<typename It::context_type::car_type::begin_type>
+        {};
+        template <typename It>
+        struct value_of
+          : result_of::value_of<typename It::context_type::car_type::begin_type>
+        {};
+        template <typename It>
+        struct value_of_data
+          : result_of::value_of_data<typename It::context_type::car_type::begin_type>
+        {};
+        template <
+            typename It1
+          , typename It2
+          , int Size1 = It1::context_type::size::value
+          , int Size2 = It2::context_type::size::value
+        >
+        struct equal_to
+          : mpl::false_
+        {};
+        template <typename It1, typename It2, int Size>
+        struct equal_to<It1, It2, Size, Size>
+          : detail::segmented_equal_to<
+                typename It1::context_type
+              , typename It2::context_type
+            >
+        {};
+        template <typename It>
+        struct next
+        {
+            typedef detail::segmented_next_impl<typename It::context_type> impl;
+            typedef segmented_iterator<typename impl::type> type;
+            static type call(It const& it)
+            {
+                return type(impl::call(it.context));
+            }
+        };
+        typedef Context context_type;
+        context_type context;
+    };
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename Second>
+    struct iterator_range;
+    template <typename Context>
+    struct segmented_iterator;
+    namespace detail
+    {
+        template <typename Sequence, typename Stack>
+        struct segmented_begin_impl;
+        template <typename Stack>
+        struct is_invalid
+          : result_of::equal_to<
+                typename Stack::car_type::begin_type,
+                typename Stack::car_type::end_type
+            >
+        {};
+        template <typename Stack>
+        struct pop_front_car
+        {
+            typedef
+                iterator_range<
+                    typename result_of::next<
+                        typename Stack::car_type::begin_type
+                    >::type
+                  , typename Stack::car_type::end_type
+                >
+            car_type;
+            typedef
+                cons<car_type, typename Stack::cdr_type>
+            type;
+            static type call(Stack const & stack)
+            {
+                return type(
+                    car_type(fusion::next(stack.car.first), stack.car.last),
+                    stack.cdr);
+            }
+        };
+        template <
+            typename Stack,
+            typename Next = typename pop_front_car<Stack>::type,
+            bool IsInvalid = is_invalid<Next>::value,
+            int StackSize = Stack::size::value>
+        struct segmented_next_impl_recurse;
+        template <
+            typename Stack,
+            int StackSize = Stack::size::value>
+        struct segmented_next_impl_recurse3
+        {
+            typedef segmented_next_impl_recurse<typename Stack::cdr_type> impl;
+            typedef typename impl::type type;
+            static type call(Stack const & stack)
+            {
+                return impl::call(stack.cdr);
+            }
+        };
+        template <typename Stack>
+        struct segmented_next_impl_recurse3<Stack, 1>
+        {
+            typedef typename Stack::car_type::end_type end_type;
+            typedef iterator_range<end_type, end_type> range_type;
+            typedef cons<range_type> type;
+            static type call(Stack const & stack)
+            {
+                return type(range_type(stack.car.last, stack.car.last));
+            }
+        };
+        template <
+            typename Stack,
+            typename Sequence =
+                typename remove_reference<
+                    typename add_const<
+                        typename result_of::deref<
+                            typename Stack::car_type::begin_type
+                        >::type
+                    >::type
+                >::type,
+            typename Result =
+                typename segmented_begin_impl<Sequence, Stack>::type,
+            bool IsInvalid =
+                is_invalid<Result>::value>
+        struct segmented_next_impl_recurse2
+        {
+            typedef segmented_next_impl_recurse3<Stack> impl;
+            typedef typename impl::type type;
+            static type call(Stack const & stack)
+            {
+                return impl::call(stack);
+            }
+        };
+        template <typename Stack, typename Sequence, typename Result>
+        struct segmented_next_impl_recurse2<Stack, Sequence, Result, false>
+        {
+            typedef Result type;
+            static type call(Stack const & stack)
+            {
+                return segmented_begin_impl<Sequence, Stack>::call(*stack.car.first, stack);
+            }
+        };
+        template <typename Stack, typename Next, bool IsInvalid, int StackSize>
+        struct segmented_next_impl_recurse
+        {
+            typedef
+                typename segmented_next_impl_recurse<typename Stack::cdr_type>::type
+            type;
+            static type call(Stack const& stack)
+            {
+                return segmented_next_impl_recurse<typename Stack::cdr_type>::call(stack.cdr);
+            }
+        };
+        template <typename Stack, typename Next>
+        struct segmented_next_impl_recurse<Stack, Next, true, 1>
+        {
+            typedef Next type;
+            static type call(Stack const & stack)
+            {
+                return pop_front_car<Stack>::call(stack);
+            }
+        };
+        template <typename Stack, typename Next, int StackSize>
+        struct segmented_next_impl_recurse<Stack, Next, false, StackSize>
+        {
+            typedef segmented_next_impl_recurse2<Next> impl;
+            typedef typename impl::type type;
+            static type call(Stack const & stack)
+            {
+                return impl::call(pop_front_car<Stack>::call(stack));
+            }
+        };
+        template <
+            typename Stack,
+            typename Next = typename pop_front_car<Stack>::type,
+            bool IsInvalid = is_invalid<Next>::value>
+        struct segmented_next_impl_aux
+        {
+            typedef segmented_next_impl_recurse<typename Stack::cdr_type> impl;
+            typedef typename impl::type type;
+            static type call(Stack const & stack)
+            {
+                return impl::call(stack.cdr);
+            }
+        };
+        template <typename Stack, typename Next>
+        struct segmented_next_impl_aux<Stack, Next, false>
+        {
+            typedef Next type;
+            static type call(Stack const & stack)
+            {
+                return pop_front_car<Stack>::call(stack);
+            }
+        };
+        template <typename Stack>
+        struct segmented_next_impl
+          : segmented_next_impl_aux<Stack>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_ {};
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct segments_impl
+        {
+            template <typename Sequence>
+            struct apply {};
+        };
+        template <>
+        struct segments_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template segments<Sequence> {};
+        };
+        template <>
+        struct segments_impl<iterator_range_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct segments
+        {
+            typedef typename traits::tag_of<Sequence>::type tag_type;
+            typedef typename
+                extension::segments_impl<tag_type>::template apply<Sequence>::type
+            type;
+        };
+    }
+    template <typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segments<Sequence>
+        >::type
+    segments(Sequence& seq)
+    {
+        typedef typename traits::tag_of<Sequence>::type tag_type;
+        return extension::segments_impl<tag_type>::template apply<Sequence>::call(seq);
+    }
+    template <typename Sequence>
+    inline typename result_of::segments<Sequence const>::type
+    segments(Sequence const& seq)
+    {
+        typedef typename traits::tag_of<Sequence const>::type tag_type;
+        return extension::segments_impl<tag_type>::template apply<Sequence const>::call(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+    template <typename Context>
+    struct segmented_iterator;
+    namespace result_of
+    {
+        template <typename Cur, typename Context>
+        struct make_segmented_iterator
+        {
+            typedef
+                iterator_range<
+                    Cur
+                  , typename result_of::end<
+                        typename remove_reference<
+                            typename add_const<
+                                typename result_of::deref<
+                                    typename Context::car_type::begin_type
+                                >::type
+                            >::type
+                        >::type
+                    >::type
+                >
+            range_type;
+            typedef
+                segmented_iterator<cons<range_type, Context> >
+            type;
+        };
+    }
+    template <typename Cur, typename Context>
+    typename result_of::make_segmented_iterator<Cur, Context>::type
+    make_segmented_iterator(Cur const& cur, Context const& context)
+    {
+        typedef result_of::make_segmented_iterator<Cur, Context> impl_type;
+        typedef typename impl_type::type type;
+        typedef typename impl_type::range_type range_type;
+        return type(cons<range_type, Context>(range_type(cur, fusion::end(*context.car.first)), context));
+    }
+    namespace detail
+    {
+        template <
+            typename Begin
+          , typename End
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsEmpty
+        >
+        struct segmented_fold_until_iterate_skip_empty;
+        template <
+            typename Begin
+          , typename End
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsDone = result_of::equal_to<Begin, End>::type::value
+        >
+        struct segmented_fold_until_iterate;
+        template <
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsSegmented = traits::is_segmented<Sequence>::type::value
+        >
+        struct segmented_fold_until_impl;
+        template <typename Segments, typename State, typename Context, typename Fun>
+        struct segmented_fold_until_on_segments;
+        template <typename Cur, typename End, typename Context>
+        struct push_context
+        {
+            typedef iterator_range<Cur, End> range_type;
+            typedef cons<range_type, Context> type;
+            static type call(Cur const& cur, End const& end, Context const& context)
+            {
+                return cons<range_type, Context>(range_type(cur, end), context);
+            }
+        };
+        template <
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun
+          , bool IsSegmented
+        >
+        struct segmented_fold_until_impl
+        {
+            typedef
+                segmented_fold_until_on_segments<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::segments<Sequence>::type
+                        >::type
+                    >::type
+                  , State
+                  , Context
+                  , Fun
+                >
+            impl;
+            typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
+            static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
+            {
+                return impl::call(fusion::segments(seq), state, context, fun);
+            }
+        };
+        template <
+            typename Sequence
+          , typename State
+          , typename Context
+          , typename Fun
+        >
+        struct segmented_fold_until_impl<Sequence, State, Context, Fun, false>
+        {
+            typedef
+                typename Fun::template apply<Sequence, State, Context>
+            apply_type;
+            typedef typename apply_type::type type;
+            typedef typename apply_type::continue_type continue_type;
+            static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
+            {
+                return apply_type::call(seq, state, context, fun);
+            }
+        };
+        template <typename Apply>
+        struct continue_wrap
+        {
+            typedef typename Apply::continue_type type;
+        };
+        template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsEmpty>
+        struct segmented_fold_until_iterate_skip_empty
+        {
+            typedef
+                push_context<Begin, End, Context>
+            push_context_impl;
+            typedef
+                typename push_context_impl::type
+            next_context_type;
+            typedef
+                segmented_fold_until_impl<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::deref<Begin>::type
+                        >::type
+                    >::type
+                  , State
+                  , next_context_type
+                  , Fun
+                >
+            fold_recurse_impl;
+            typedef
+                typename fold_recurse_impl::type
+            next_state_type;
+            typedef
+                segmented_fold_until_iterate<
+                    typename result_of::next<Begin>::type
+                  , End
+                  , next_state_type
+                  , Context
+                  , Fun
+                >
+            next_iteration_impl;
+            typedef
+                typename mpl::eval_if<
+                    typename fold_recurse_impl::continue_type
+                  , next_iteration_impl
+                  , mpl::identity<next_state_type>
+                >::type
+            type;
+            typedef
+                typename mpl::eval_if<
+                    typename fold_recurse_impl::continue_type
+                  , continue_wrap<next_iteration_impl>
+                  , mpl::identity<mpl::false_>
+                >::type
+            continue_type;
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
+            {
+                return call(beg, end, state, context, fun, typename fold_recurse_impl::continue_type());
+            }
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun, mpl::true_)
+            {
+                return next_iteration_impl::call(
+                    fusion::next(beg)
+                  , end
+                  , fold_recurse_impl::call(
+                        *beg
+                      , state
+                      , push_context_impl::call(beg, end, context)
+                      , fun)
+                  , context
+                  , fun);
+            }
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun, mpl::false_)
+            {
+                return fold_recurse_impl::call(
+                    *beg
+                  , state
+                  , push_context_impl::call(beg, end, context)
+                  , fun);
+            }
+        };
+        template <typename Begin, typename End, typename State, typename Context, typename Fun>
+        struct segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, true>
+        {
+            typedef
+                segmented_fold_until_iterate<
+                    typename result_of::next<Begin>::type
+                  , End
+                  , State
+                  , Context
+                  , Fun
+                >
+            impl;
+            typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
+            {
+                return impl::call(fusion::next(beg), end, state, context, fun);
+            }
+        };
+        template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsDone>
+        struct segmented_fold_until_iterate
+        {
+            typedef
+                typename result_of::empty<
+                    typename remove_reference<
+                        typename result_of::deref<Begin>::type
+                    >::type
+                >::type
+            empty_type;
+            typedef
+                segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, empty_type::value>
+            impl;
+            typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
+            static type call(Begin const& beg, End const& end, State const& state
+                           , Context const& context, Fun const& fun)
+            {
+                return impl::call(beg, end, state, context, fun);
+            }
+        };
+        template <typename Begin, typename End, typename State, typename Context, typename Fun>
+        struct segmented_fold_until_iterate<Begin, End, State, Context, Fun, true>
+        {
+            typedef State type;
+            typedef mpl::true_ continue_type;
+            static type call(Begin const&, End const&, State const& state
+                           , Context const&, Fun const&)
+            {
+                return state;
+            }
+        };
+        template <typename Segments, typename State, typename Context, typename Fun>
+        struct segmented_fold_until_on_segments
+        {
+            typedef
+                segmented_fold_until_iterate<
+                    typename result_of::begin<Segments>::type
+                  , typename result_of::end<Segments>::type
+                  , State
+                  , Context
+                  , Fun
+                >
+            impl;
+            typedef typename impl::type type;
+            typedef typename impl::continue_type continue_type;
+            static type call(Segments& segs, State const& state, Context const& context, Fun const& fun)
+            {
+                return impl::call(fusion::begin(segs), fusion::end(segs), state, context, fun);
+            }
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    struct segmented_begin_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                iterator_range<
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type
+                >
+            range_type;
+            typedef cons<range_type, Context> type;
+            typedef mpl::false_ continue_type;
+            static type call(Sequence& seq, State const&, Context const& context, segmented_begin_fun)
+            {
+                return type(range_type(fusion::begin(seq), fusion::end(seq)), context);
+            }
+        };
+    };
+    template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value>
+    struct segmented_begin_impl_aux
+    {
+        typedef
+            segmented_end_impl<Sequence, Stack>
+        end_impl;
+        typedef
+            segmented_fold_until_impl<
+                Sequence
+              , typename end_impl::type
+              , Stack
+              , segmented_begin_fun
+            >
+        fold_impl;
+        typedef typename fold_impl::type type;
+        static type call(Sequence& seq, Stack const& stack)
+        {
+            return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun());
+        }
+    };
+    template <typename Sequence, typename Stack>
+    struct segmented_begin_impl_aux<Sequence, Stack, false>
+    {
+        typedef typename result_of::begin<Sequence>::type begin_type;
+        typedef typename result_of::end<Sequence>::type end_type;
+        typedef iterator_range<begin_type, end_type> pair_type;
+        typedef cons<pair_type, Stack> type;
+        static type call(Sequence& seq, Stack stack)
+        {
+            return type(pair_type(fusion::begin(seq), fusion::end(seq)), stack);
+        }
+    };
+    template <typename Sequence, typename Stack>
+    struct segmented_begin_impl
+      : segmented_begin_impl_aux<Sequence, Stack>
+    {};
+}}}
+namespace boost { namespace fusion
+{
+    struct random_access_traversal_tag;
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct distance_impl
+        {
+            template <typename First, typename Last>
+            struct apply : distance_detail::linear_distance<First, Last>
+            {};
+        };
+        template <>
+        struct distance_impl<iterator_facade_tag>
+        {
+            template <typename First, typename Last>
+            struct apply : First::template distance<First, Last> {};
+        };
+        template <>
+        struct distance_impl<boost_array_iterator_tag>;
+        template <>
+        struct distance_impl<mpl_iterator_tag>;
+        template <>
+        struct distance_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename First, typename Last>
+        struct distance
+          : extension::distance_impl<typename detail::tag_of<First>::type>::
+                template apply<First, Last>
+        {
+            typedef typename extension::distance_impl<typename detail::tag_of<First>::type>::
+            template apply<First, Last>::type distance_application;
+            static const int value = distance_application::value;
+        };
+    }
+    template <typename First, typename Last>
+    inline typename result_of::distance<First, Last>::type
+    distance(First const& a, Last const& b)
+    {
+        return result_of::distance<First, Last>::call(a,b);
+    }
+}}
+namespace boost { namespace fusion
+{
+    template <typename Iterator>
+    struct mpl_iterator;
+    template <typename T>
+    struct convert_iterator
+    {
+        typedef typename
+            mpl::if_<
+                is_fusion_iterator<T>
+              , T
+              , mpl_iterator<T>
+            >::type
+        type;
+        static T const&
+        call(T const& x, mpl::true_)
+        {
+            return x;
+        }
+        static mpl_iterator<T>
+        call(T const& , mpl::false_)
+        {
+            return mpl_iterator<T>();
+        }
+        static typename
+            mpl::if_<
+                is_fusion_iterator<T>
+              , T const&
+              , mpl_iterator<T>
+            >::type
+        call(T const& x)
+        {
+            return call(x, is_fusion_iterator<T>());
+        }
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<iterator_range_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::begin_type type;
+                static type
+                call(Sequence& s)
+                {
+                    return s.first;
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<iterator_range_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::end_type type;
+                static type
+                call(Sequence& s)
+                {
+                    return s.last;
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct random_access_traversal_tag;
+    struct iterator_facade_tag;
+    struct boost_array_iterator_tag;
+    struct mpl_iterator_tag;
+    struct std_pair_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct advance_impl
+        {
+            template <typename Iterator, typename N>
+            struct apply :
+                mpl::if_c<
+                    (N::value > 0)
+                  , advance_detail::forward<Iterator, N::value>
+                  , advance_detail::backward<Iterator, N::value>
+                >::type
+            {
+                enum { mpl_assertion_in_line_42 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (traits::is_random_access<Iterator>))0, 1 ) ) ) };
+            };
+        };
+        template <>
+        struct advance_impl<iterator_facade_tag>
+        {
+            template <typename Iterator, typename N>
+            struct apply : Iterator::template advance<Iterator, N> {};
+        };
+        template <>
+        struct advance_impl<boost_array_iterator_tag>;
+        template <>
+        struct advance_impl<mpl_iterator_tag>;
+        template <>
+        struct advance_impl<std_pair_iterator_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Iterator, int N>
+        struct advance_c
+            : extension::advance_impl<typename detail::tag_of<Iterator>::type>::template apply<Iterator, mpl::int_<N> >
+        {};
+        template <typename Iterator, typename N>
+        struct advance
+            : extension::advance_impl<typename detail::tag_of<Iterator>::type>::template apply<Iterator, N>
+        {};
+    }
+    template <int N, typename Iterator>
+    inline typename result_of::advance_c<Iterator, N>::type const
+    advance_c(Iterator const& i)
+    {
+        return result_of::advance_c<Iterator, N>::call(i);
+    }
+    template<typename N, typename Iterator>
+    inline typename result_of::advance<Iterator, N>::type const
+    advance(Iterator const& i)
+    {
+        return result_of::advance<Iterator, N>::call(i);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+        template <>
+        struct at_impl<iterator_range_tag>
+        {
+            template <typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::begin_type begin_type;
+                typedef typename result_of::advance<begin_type,N>::type pos;
+                typedef typename result_of::deref<pos>::type type;
+                static type
+                call(Seq& s)
+                {
+                    return * fusion::advance<N>(s.first);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct size_impl;
+        template <>
+        struct size_impl<iterator_range_tag>
+        {
+            template <typename Seq>
+            struct apply
+              : result_of::distance<
+                    typename Seq::begin_type,
+                    typename Seq::end_type
+                >
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl;
+        template <>
+        struct value_at_impl<iterator_range_tag>
+        {
+            template <typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::begin_type begin_type;
+                typedef typename result_of::advance<begin_type,N>::type pos;
+                typedef typename result_of::value_of<pos>::type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    template <typename Context>
+    struct segmented_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct is_segmented_impl;
+        template <>
+        struct is_segmented_impl<iterator_range_tag>
+        {
+        private:
+            template <typename Iterator>
+            struct is_segmented_iterator
+              : mpl::false_
+            {};
+            template <typename Iterator>
+            struct is_segmented_iterator<Iterator &>
+              : is_segmented_iterator<Iterator>
+            {};
+            template <typename Iterator>
+            struct is_segmented_iterator<Iterator const>
+              : is_segmented_iterator<Iterator>
+            {};
+            template <typename Context>
+            struct is_segmented_iterator<segmented_iterator<Context> >
+              : mpl::true_
+            {};
+        public:
+            template <typename Sequence>
+            struct apply
+              : is_segmented_iterator<typename Sequence::begin_type>
+            {
+                enum {
+ mpl_assert_rel_value58
+                = (is_segmented_iterator<typename Sequence::begin_type>::value == is_segmented_iterator<typename Sequence::end_type>::value) }; enum { mpl_assertion_in_line_58 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value58>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , is_segmented_iterator<typename Sequence::begin_type>::value , is_segmented_iterator<typename Sequence::end_type>::value >::************)) 0 ) ) }
+                                                                              ;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct as_fusion_element
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct as_fusion_element<reference_wrapper<T> >
+    {
+        typedef T& type;
+    };
+    template <typename T, int N>
+    struct as_fusion_element<T[N]>
+    {
+        typedef const T(&type)[N];
+    };
+    template <typename T, int N>
+    struct as_fusion_element<volatile T[N]>
+    {
+        typedef const volatile T(&type)[N];
+    };
+    template <typename T, int N>
+    struct as_fusion_element<const volatile T[N]>
+    {
+        typedef const volatile T(&type)[N];
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct joint_view_tag;
+    template <typename Sequence1, typename Sequence2>
+    struct joint_view;
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct O1_size_impl;
+template< typename Sequence > struct O1_size;
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Sequence > struct O1_size_impl
+    : Sequence::size
+{
+};
+}
+template< typename Tag >
+struct O1_size_impl
+{
+    template< typename Sequence > struct apply
+        : if_<
+              aux::has_size<Sequence>
+            , aux::O1_size_impl<Sequence>
+            , long_<-1>
+            >::type
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct O1_size
+    : O1_size_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct apply;
+template<
+      typename F
+    >
+struct apply0;
+template<
+      typename F, typename T1
+    >
+struct apply1;
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2;
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3;
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4;
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5;
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+namespace boost { namespace mpl {
+template<
+      typename F
+    , typename has_apply_ = typename aux::has_apply<F>::type
+    >
+struct apply_wrap0
+    : F::template apply< >
+{
+};
+template< typename F >
+struct apply_wrap0< F,true_ >
+    : F::apply
+{
+};
+template<
+      typename F, typename T1
+    >
+struct apply_wrap1
+    : F::template apply<T1>
+{
+};
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply_wrap2
+    : F::template apply< T1,T2 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply_wrap3
+    : F::template apply< T1,T2,T3 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply_wrap4
+    : F::template apply< T1,T2,T3,T4 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply_wrap5
+    : F::template apply< T1,T2,T3,T4,T5 >
+{
+};
+}}
+namespace mpl_ {
+template< int N > struct arg;
+}
+namespace boost { namespace mpl { using ::mpl_::arg; } }
+namespace mpl_ {
+template<> struct arg< -1 >
+{
+    static const int value = -1;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+template<> struct arg<1>
+{
+    static const int value = 1;
+    typedef arg<2> next;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+template<> struct arg<2>
+{
+    static const int value = 2;
+    typedef arg<3> next;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U2 type;
+        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+template<> struct arg<3>
+{
+    static const int value = 3;
+    typedef arg<4> next;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U3 type;
+        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+template<> struct arg<4>
+{
+    static const int value = 4;
+    typedef arg<5> next;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U4 type;
+        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+template<> struct arg<5>
+{
+    static const int value = 5;
+    typedef arg<6> next;
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U5 type;
+        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+}
+namespace mpl_ {
+typedef arg< -1 > _;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_;
+namespace placeholders {
+using mpl_::_;
+}
+}}
+namespace mpl_ {
+typedef arg<1> _1;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_1;
+namespace placeholders {
+using mpl_::_1;
+}
+}}
+namespace mpl_ {
+typedef arg<2> _2;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_2;
+namespace placeholders {
+using mpl_::_2;
+}
+}}
+namespace mpl_ {
+typedef arg<3> _3;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_3;
+namespace placeholders {
+using mpl_::_3;
+}
+}}
+namespace mpl_ {
+typedef arg<4> _4;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_4;
+namespace placeholders {
+using mpl_::_4;
+}
+}}
+namespace mpl_ {
+typedef arg<5> _5;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_5;
+namespace placeholders {
+using mpl_::_5;
+}
+}}
+namespace mpl_ {
+typedef arg<6> _6;
+}
+namespace boost { namespace mpl {
+using ::mpl_::_6;
+namespace placeholders {
+using mpl_::_6;
+}
+}}
+namespace boost { namespace mpl {
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct bind;
+template<
+      typename F
+    >
+struct bind0;
+template<
+      typename F, typename T1
+    >
+struct bind1;
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2;
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3;
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4;
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5;
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    , int not_le_ = 0
+    >
+struct protect : T
+{
+    typedef protect type;
+};
+template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };
+namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template<
+      typename T, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg
+{
+    typedef T type;
+};
+template<
+      typename T
+    , typename Arg
+    >
+struct replace_unnamed_arg
+{
+    typedef Arg next;
+    typedef T type;
+};
+template<
+      typename Arg
+    >
+struct replace_unnamed_arg< arg< -1 >, Arg >
+{
+    typedef typename Arg::next next;
+    typedef Arg type;
+};
+template<
+      int N, typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
+{
+    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
+{
+    typedef bind< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+template<
+      typename F
+    >
+struct bind0
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+     public:
+        typedef typename apply_wrap0<
+              f_
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind0<F>, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind0<F> f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }
+template<
+      typename F
+    >
+struct bind< F,na,na,na,na,na >
+    : bind0<F>
+{
+};
+template<
+      typename F, typename T1
+    >
+struct bind1
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+     public:
+        typedef typename apply_wrap1<
+              f_
+            , typename t1::type
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename T1, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind1< F,T1 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind1< F,T1 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }
+template<
+      typename F, typename T1
+    >
+struct bind< F,T1,na,na,na,na >
+    : bind1< F,T1 >
+{
+};
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+     public:
+        typedef typename apply_wrap2<
+              f_
+            , typename t1::type, typename t2::type
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename T1, typename T2, typename U1, typename U2
+    , typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind2< F,T1,T2 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind< F,T1,T2,na,na,na >
+    : bind2< F,T1,T2 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+     public:
+        typedef typename apply_wrap3<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename T1, typename T2, typename T3, typename U1
+    , typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind3< F,T1,T2,T3 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind< F,T1,T2,T3,na,na >
+    : bind3< F,T1,T2,T3 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+     public:
+        typedef typename apply_wrap4<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind4< F,T1,T2,T3,T4 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind< F,T1,T2,T3,T4,na >
+    : bind4< F,T1,T2,T3,T4 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+        typedef aux::replace_unnamed_arg< T5,n5 > r5;
+        typedef typename r5::type a5;
+        typedef typename r5::next n6;
+        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;
+     public:
+        typedef typename apply_wrap5<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type, typename t5::type
+            >::type type;
+    };
+};
+namespace aux {
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+}
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind
+    : bind5< F,T1,T2,T3,T4,T5 >
+{
+};
+template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
+struct quote3;
+template< typename T1, typename T2, typename T3 > struct if_;
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< if_,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+        typedef typename if_<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+     public:
+        typedef typename f_::type type;
+    };
+};
+template<
+      template< typename T1, typename T2, typename T3 > class F, typename Tag
+    >
+struct quote3;
+template< typename T1, typename T2, typename T3 > struct eval_if;
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< eval_if,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+        typedef typename eval_if<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+     public:
+        typedef typename f_::type type;
+    };
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+namespace boost { namespace mpl {
+template< typename T, bool has_type_ >
+struct quote_impl
+{
+    typedef typename T::type type;
+};
+template< typename T >
+struct quote_impl< T,false >
+{
+    typedef T type;
+};
+template<
+      template< typename P1 > class F
+    , typename Tag = void_
+    >
+struct quote1
+{
+    template< typename U1 > struct apply
+        : quote_impl<
+              F<U1>
+            , aux::has_type< F<U1> >::value
+            >
+    {
+    };
+};
+template<
+      template< typename P1, typename P2 > class F
+    , typename Tag = void_
+    >
+struct quote2
+{
+    template< typename U1, typename U2 > struct apply
+        : quote_impl<
+              F< U1,U2 >
+            , aux::has_type< F< U1,U2 > >::value
+            >
+    {
+    };
+};
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename Tag = void_
+    >
+struct quote3
+{
+    template< typename U1, typename U2, typename U3 > struct apply
+        : quote_impl<
+              F< U1,U2,U3 >
+            , aux::has_type< F< U1,U2,U3 > >::value
+            >
+    {
+    };
+};
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename Tag = void_
+    >
+struct quote4
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        >
+    struct apply
+        : quote_impl<
+              F< U1,U2,U3,U4 >
+            , aux::has_type< F< U1,U2,U3,U4 > >::value
+            >
+    {
+    };
+};
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename Tag = void_
+    >
+struct quote5
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        , typename U5
+        >
+    struct apply
+        : quote_impl<
+              F< U1,U2,U3,U4,U5 >
+            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template< int N > struct arity_tag
+{
+    typedef char (&type)[N + 1];
+};
+template<
+      int C1, int C2, int C3, int C4, int C5, int C6
+    >
+struct max_arity
+{
+    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )
+         ;
+};
+arity_tag<0>::type arity_helper(...);
+template<
+      template< typename P1 > class F
+    , typename T1
+    >
+typename arity_tag<1>::type
+arity_helper(type_wrapper< F<T1> >, arity_tag<1>);
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    >
+typename arity_tag<2>::type
+arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    >
+typename arity_tag<3>::type
+arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    >
+typename arity_tag<4>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);
+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 arity_tag<5>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5, typename P6
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , typename T6
+    >
+typename arity_tag<6>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
+template< typename F, int N >
+struct template_arity_impl
+{
+    static const int value = sizeof(::boost::mpl::aux::arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1
+         ;
+};
+template< typename F >
+struct template_arity
+{
+    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )
+          ;
+    typedef mpl::int_<value> type;
+};
+}}}
+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_
+{
+};
+}
+template<
+      typename T
+    , typename Tag
+    , typename Arity
+    >
+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, int_< -1 > >
+{
+    typedef true_ is_le;
+    typedef mpl::arg<N> result_;
+    typedef mpl::protect<result_> type;
+};
+template<
+      typename F
+    , typename Tag
+    >
+struct lambda<
+          bind0<F>
+        , Tag
+        , int_<1>
+        >
+{
+    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;
+};
+}
+template<
+      template< typename P1 > class F
+    , typename T1
+    , typename Tag
+    >
+struct lambda<
+          F<T1>
+        , Tag
+        , int_<1>
+        >
+{
+    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
+        , int_<2>
+        >
+{
+    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;
+};
+}
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2 >
+        , Tag
+        , int_<2>
+        >
+{
+    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
+        , int_<3>
+        >
+{
+    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;
+};
+}
+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
+        , int_<3>
+        >
+{
+    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
+        , int_<4>
+        >
+{
+    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;
+};
+}
+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
+        , int_<4>
+        >
+{
+    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
+        , int_<5>
+        >
+{
+    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;
+};
+}
+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
+        , int_<5>
+        >
+{
+    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
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind5<
+          F
+        , T1, T2, T3, T4, T5
+        > result_;
+    typedef result_ type;
+};
+template< typename T, typename Tag >
+struct lambda< mpl::protect<T>,Tag, int_<1> >
+{
+    typedef false_ is_le;
+    typedef mpl::protect<T> result_;
+    typedef result_ type;
+};
+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
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind< F,T1,T2,T3,T4,T5 > result_;
+    typedef result_ type;
+};
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    , typename Arity
+    >
+struct lambda<
+          lambda< F,Tag1,Arity >
+        , Tag2
+        , int_<3>
+        >
+{
+    typedef lambda< F,Tag2 > l1;
+    typedef lambda< Tag1,Tag2 > l2;
+    typedef typename l1::is_le is_le;
+    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
+    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
+    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename F
+    >
+struct apply0
+    : apply_wrap0<
+          typename lambda<F>::type
+        >
+{
+};
+template<
+      typename F
+    >
+struct apply< F,na,na,na,na,na >
+    : apply0<F>
+{
+};
+template<
+      typename F, typename T1
+    >
+struct apply1
+    : apply_wrap1<
+          typename lambda<F>::type
+        , T1
+        >
+{
+};
+template<
+      typename F, typename T1
+    >
+struct apply< F,T1,na,na,na,na >
+    : apply1< F,T1 >
+{
+};
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2
+    : apply_wrap2<
+          typename lambda<F>::type
+        , T1, T2
+        >
+{
+};
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply< F,T1,T2,na,na,na >
+    : apply2< F,T1,T2 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3
+    : apply_wrap3<
+          typename lambda<F>::type
+        , T1, T2, T3
+        >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply< F,T1,T2,T3,na,na >
+    : apply3< F,T1,T2,T3 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4
+    : apply_wrap4<
+          typename lambda<F>::type
+        , T1, T2, T3, T4
+        >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply< F,T1,T2,T3,T4,na >
+    : apply4< F,T1,T2,T3,T4 >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5
+    : apply_wrap5<
+          typename lambda<F>::type
+        , T1, T2, T3, T4, T5
+        >
+{
+};
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply
+    : apply5< F,T1,T2,T3,T4,T5 >
+{
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct msvc_type
+{
+    typedef typename T::type type;
+};
+template<> struct msvc_type<int>
+{
+    typedef int type;
+};
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Iterator = na
+    >
+struct deref
+{
+    typedef typename Iterator::type type;
+};
+template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl;
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 0,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef state0 state;
+    typedef iter0 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 1,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef state1 state;
+    typedef iter1 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 2,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef state2 state;
+    typedef iter2 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 3,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef state3 state;
+    typedef iter3 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 4,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp, state0, typename deref<iter0>::type >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, state1, typename deref<iter1>::type >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp, state2, typename deref<iter2>::type >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef typename apply2< ForwardOp, state3, typename deref<iter3>::type >::type state4;
+    typedef typename mpl::next<iter3>::type iter4;
+    typedef state4 state;
+    typedef iter4 iterator;
+};
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl
+{
+    typedef fold_impl<
+          4
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+    typedef fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< -1,First,Last,State,ForwardOp >
+    : fold_impl<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2<ForwardOp,State, typename deref<First>::type>::type
+        , ForwardOp
+        >
+{
+};
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< -1,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename State = na
+    , typename ForwardOp = na
+    >
+struct fold
+{
+    typedef typename aux::fold_impl<
+          ::boost::mpl::O1_size<Sequence>::value
+        , typename begin<Sequence>::type
+        , typename end<Sequence>::type
+        , State
+        , ForwardOp
+        >::state type;
+};
+template<> struct fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef fold< na , na , na > result_; typedef fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< fold< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct integral_rank;
+template<> struct integral_rank<bool> : int_<1> {};
+template<> struct integral_rank<signed char> : int_<2> {};
+template<> struct integral_rank<char> : int_<3> {};
+template<> struct integral_rank<unsigned char> : int_<4> {};
+template<> struct integral_rank<wchar_t> : int_<5> {};
+template<> struct integral_rank<short> : int_<6> {};
+template<> struct integral_rank<unsigned short> : int_<7> {};
+template<> struct integral_rank<int> : int_<8> {};
+template<> struct integral_rank<unsigned int> : int_<9> {};
+template<> struct integral_rank<long> : int_<10> {};
+template<> struct integral_rank<unsigned long> : int_<11> {};
+template<> struct integral_rank<long_long_type> : int_<12> {};
+template<> struct integral_rank<ulong_long_type>: int_<13> {};
+template< typename T1, typename T2 > struct largest_int
+    : if_c<
+          ( integral_rank<T1>::value >= integral_rank<T2>::value )
+        , T1
+        , T2
+        >
+{
+};
+}}}
+namespace boost { namespace mpl {
+template< typename SourceTag, typename TargetTag > struct numeric_cast
+{
+    template< typename N > struct apply;
+};
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename T > struct tag_impl
+{
+    typedef typename T::tag type;
+};
+}
+template< typename T, typename Default = void_ > struct tag
+    : if_<
+          aux::has_tag<T>
+        , aux::tag_impl<T>
+        , Default
+        >::type
+{
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast1st_impl
+{
+    template< typename N1, typename N2 > struct apply
+        : apply_wrap2<
+              F
+            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
+            , N2
+            >
+    {
+    };
+};
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast2nd_impl
+{
+    template< typename N1, typename N2 > struct apply
+        : apply_wrap2<
+              F
+            , N1
+            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
+            >
+    {
+    };
+};
+}}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct msvc_eti_base
+    : T
+{
+    msvc_eti_base();
+    typedef T type;
+};
+template<> struct msvc_eti_base<int>
+{
+    typedef msvc_eti_base type;
+    typedef msvc_eti_base first;
+    typedef msvc_eti_base second;
+    typedef msvc_eti_base tag;
+    enum { value = 0 };
+};
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct plus_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct plus_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct plus_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct plus_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct plus_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct plus
+    : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
+{
+};
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct plus< N1,N2,N3,N4,na >
+    : plus< plus< plus< N1,N2 >, N3>, N4>
+{
+};
+template<
+      typename N1, typename N2, typename N3
+    >
+struct plus< N1,N2,N3,na,na >
+    : plus< plus< N1,N2 >, N3>
+{
+};
+template<
+      typename N1, typename N2
+    >
+struct plus< N1,N2,na,na,na >
+    : plus_impl<
+          typename plus_tag<N1>::type
+        , typename plus_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct plus_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  + N2::value
+                )
+            >
+    {
+    };
+};
+}}
+namespace mpl_ {
+template< std::size_t N > struct size_t;
+}
+namespace boost { namespace mpl { using ::mpl_::size_t; } }
+namespace mpl_ {
+template< std::size_t N >
+struct size_t
+{
+    static const std::size_t value = N;
+    typedef size_t type;
+    typedef std::size_t value_type;
+    typedef integral_c_tag tag;
+    typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
+    typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;
+    operator std::size_t() const { return static_cast<std::size_t>(this->value); }
+};
+template< std::size_t N >
+std::size_t const mpl_::size_t< N >::value;
+}
+namespace boost { namespace mpl
+{
+    struct forward_iterator_tag;
+    struct bidirectional_iterator_tag;
+    struct random_access_iterator_tag;
+}}
+namespace boost { namespace fusion
+{
+    struct forward_traversal_tag;
+    struct bidirectional_traversal_tag;
+    struct random_access_traversal_tag;
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Category>
+    struct mpl_iterator_category;
+    template <>
+    struct mpl_iterator_category<mpl::forward_iterator_tag>
+    {
+        typedef forward_traversal_tag type;
+    };
+    template <>
+    struct mpl_iterator_category<mpl::bidirectional_iterator_tag>
+    {
+        typedef bidirectional_traversal_tag type;
+    };
+    template <>
+    struct mpl_iterator_category<mpl::random_access_iterator_tag>
+    {
+        typedef random_access_traversal_tag type;
+    };
+    template <>
+    struct mpl_iterator_category<forward_traversal_tag>
+    {
+        typedef forward_traversal_tag type;
+    };
+    template <>
+    struct mpl_iterator_category<bidirectional_traversal_tag>
+    {
+        typedef bidirectional_traversal_tag type;
+    };
+    template <>
+    struct mpl_iterator_category<random_access_traversal_tag>
+    {
+        typedef random_access_traversal_tag type;
+    };
+}}}
+namespace boost { namespace mpl {
+template< typename Tag > struct advance_impl;
+template< typename Iterator, typename N > struct advance;
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct less_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct less_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct less_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct less_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct less_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct less
+    : less_impl<
+          typename less_tag<N1>::type
+        , typename less_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct less_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N2::value > N1::value ) >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct negate_impl;
+template< typename T > struct negate_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N = na
+    >
+struct negate
+    : negate_impl<
+          typename negate_tag<N>::type
+        >::template apply<N>::type
+{
+};
+template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
+template<>
+struct negate_impl<integral_c_tag>
+{
+    template< typename N > struct apply
+        : integral_c< typename N::value_type, (-N::value) >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template< long N > struct advance_forward;
+template<>
+struct advance_forward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+};
+template<>
+struct advance_forward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef iter1 type;
+    };
+};
+template<>
+struct advance_forward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef iter2 type;
+    };
+};
+template<>
+struct advance_forward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef typename next<iter2>::type iter3;
+        typedef iter3 type;
+    };
+};
+template<>
+struct advance_forward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef typename next<iter2>::type iter3;
+        typedef typename next<iter3>::type iter4;
+        typedef iter4 type;
+    };
+};
+template< long N >
+struct advance_forward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_forward<4>
+            , Iterator
+            >::type chunk_result_;
+        typedef typename apply_wrap1<
+              advance_forward<(
+                (N - 4) < 0
+                    ? 0
+                    : N - 4
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+}}}
+namespace boost { namespace mpl { namespace aux {
+template< long N > struct advance_backward;
+template<>
+struct advance_backward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+};
+template<>
+struct advance_backward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef iter1 type;
+    };
+};
+template<>
+struct advance_backward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef iter2 type;
+    };
+};
+template<>
+struct advance_backward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef typename prior<iter2>::type iter3;
+        typedef iter3 type;
+    };
+};
+template<>
+struct advance_backward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef typename prior<iter2>::type iter3;
+        typedef typename prior<iter3>::type iter4;
+        typedef iter4 type;
+    };
+};
+template< long N >
+struct advance_backward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_backward<4>
+            , Iterator
+            >::type chunk_result_;
+        typedef typename apply_wrap1<
+              advance_backward<(
+                (N - 4) < 0
+                    ? 0
+                    : N - 4
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+}}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct advance_impl
+{
+    template< typename Iterator, typename N > struct apply
+    {
+        typedef typename less< N,long_<0> >::type backward_;
+        typedef typename if_< backward_, negate<N>, N >::type offset_;
+        typedef typename if_<
+              backward_
+            , aux::advance_backward< offset_::value >
+            , aux::advance_forward< offset_::value >
+            >::type f_;
+        typedef typename apply_wrap1<f_,Iterator>::type type;
+    };
+};
+template<
+      typename Iterator = na
+    , typename N = na
+    >
+struct advance
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,N>
+{
+};
+template<
+      typename Iterator
+    , long N
+    >
+struct advance_c
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,long_<N> >
+{
+};
+template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct distance_impl;
+template< typename First, typename Last > struct distance;
+}}
+namespace boost { namespace mpl { namespace aux {
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl;
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 0,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef state0 state;
+    typedef iter0 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 1,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef state1 state;
+    typedef iter1 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 2,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef state2 state;
+    typedef iter2 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 3,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef state3 state;
+    typedef iter3 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 4,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
+    typedef typename mpl::next<iter3>::type iter4;
+    typedef state4 state;
+    typedef iter4 iterator;
+};
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl
+{
+    typedef iter_fold_impl<
+          4
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+    typedef iter_fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< -1,First,Last,State,ForwardOp >
+    : iter_fold_impl<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2< ForwardOp,State,First >::type
+        , ForwardOp
+        >
+{
+};
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename State = na
+    , typename ForwardOp = na
+    >
+struct iter_fold
+{
+    typedef typename aux::iter_fold_impl<
+          ::boost::mpl::O1_size<Sequence>::value
+        , typename begin<Sequence>::type
+        , typename end<Sequence>::type
+        , State
+        , typename lambda<ForwardOp>::type
+        >::state type;
+};
+template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+struct iterator_range_tag;
+template<
+      typename First = na
+    , typename Last = na
+    >
+struct iterator_range
+{
+    typedef iterator_range_tag tag;
+    typedef iterator_range type;
+    typedef First begin;
+    typedef Last end;
+};
+template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct distance_impl
+{
+    template< typename First, typename Last > struct apply
+        : aux::msvc_eti_base< typename iter_fold<
+              iterator_range<First,Last>
+            , mpl::long_<0>
+            , next<>
+            >::type >
+    {
+    };
+};
+template<
+      typename First = na
+    , typename Last = na
+    >
+struct distance
+    : distance_impl< typename tag<First>::type >
+        ::template apply<First, Last>
+{
+};
+template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    template <typename Iterator_>
+    struct mpl_iterator
+        : iterator_facade<
+            mpl_iterator<Iterator_>
+          , typename detail::mpl_iterator_category<typename Iterator_::category>::type
+        >
+    {
+        typedef typename remove_const<Iterator_>::type iterator_type;
+        template <typename Iterator>
+        struct value_of : mpl::deref<typename Iterator::iterator_type> {};
+        template <typename Iterator>
+        struct deref
+        {
+            typedef typename mpl::deref<
+                typename Iterator::iterator_type>::type
+            type;
+            static type
+            call(Iterator)
+            {
+                return type();
+            }
+        };
+        template <typename Iterator>
+        struct next
+        {
+            typedef mpl_iterator<
+                typename mpl::next<typename Iterator::iterator_type>::type>
+            type;
+            static type
+            call(Iterator)
+            {
+                return type();
+            }
+        };
+        template <typename Iterator>
+        struct prior
+        {
+            typedef mpl_iterator<
+                typename mpl::prior<typename Iterator::iterator_type>::type>
+            type;
+            static type
+            call(Iterator)
+            {
+                return type();
+            }
+        };
+        template <typename Iterator, typename N>
+        struct advance
+        {
+            typedef mpl_iterator<
+                typename mpl::advance<typename Iterator::iterator_type, N>::type>
+            type;
+            static type
+            call(Iterator const& )
+            {
+                return type();
+            }
+        };
+        template <typename I1, typename I2>
+        struct distance :
+            mpl::distance<
+                typename I1::iterator_type
+              , typename I2::iterator_type>
+        {
+            typedef typename
+                mpl::distance<
+                    typename I1::iterator_type
+                  , typename I2::iterator_type
+                >::type
+            type;
+            static type
+            call(I1 const&, I2 const&)
+            {
+                return type();
+            }
+        };
+    };
+}}
+namespace boost { namespace fusion {
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename mpl::begin<
+                    typename remove_const<Sequence>::type
+                >::type iterator;
+                typedef mpl_iterator<iterator> type;
+                static type
+                call(Sequence)
+                {
+                    return type();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl {
+struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
+struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
+struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };
+}}
+namespace boost { namespace fusion { namespace detail
+{
+template<class Category>
+struct to_mpl_category {
+    typedef typename mpl::eval_if<
+        is_base_of<random_access_traversal_tag, Category>,
+        mpl::random_access_iterator_tag,
+        mpl::eval_if<
+            is_base_of<bidirectional_traversal_tag, Category>,
+            mpl::bidirectional_iterator_tag,
+            mpl::forward_iterator_tag
+        >
+    >::type type;
+};
+}}}
+namespace boost { namespace mpl
+{
+    template <typename Iterator>
+    struct fusion_iterator
+    {
+        typedef typename fusion::result_of::value_of<Iterator>::type type;
+        typedef typename fusion::traits::category_of<Iterator>::type fusion_category;
+        typedef typename fusion::detail::to_mpl_category<fusion_category>::type category;
+        typedef Iterator iterator;
+    };
+    template <typename Iterator>
+    struct next<fusion_iterator<Iterator> >
+    {
+        typedef fusion_iterator<typename fusion::result_of::next<Iterator>::type> type;
+    };
+    template <typename Iterator>
+    struct prior<fusion_iterator<Iterator> >
+    {
+        typedef fusion_iterator<typename fusion::result_of::prior<Iterator>::type> type;
+    };
+    template <typename Iterator, typename N>
+    struct advance<fusion_iterator<Iterator>, N>
+    {
+        typedef fusion_iterator<typename fusion::result_of::advance<Iterator, N>::type> type;
+    };
+    template <typename First, typename Last>
+    struct distance<fusion_iterator<First>, fusion_iterator<Last> >
+        : fusion::result_of::distance<First, Last>
+    {};
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct begin_impl;
+    template <>
+    struct begin_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply
+        {
+            typedef fusion_iterator<typename fusion::result_of::begin<Sequence>::type> type;
+        };
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename mpl::end<
+                    typename remove_const<Sequence>::type
+                >::type iterator;
+                typedef mpl_iterator<iterator> type;
+                static type
+                call(Sequence)
+                {
+                    return type();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct end_impl;
+    template <>
+    struct end_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply
+        {
+            typedef fusion_iterator<typename fusion::result_of::end<Sequence>::type> type;
+        };
+    };
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template<typename Sequence>
+    struct segmented_size;
+    template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
+    struct segmented_size_impl
+      : mpl::fold<
+            typename remove_reference<
+                typename add_const<
+                    typename result_of::segments<Sequence>::type
+                >::type
+            >::type
+          , mpl::size_t<0>
+          , mpl::plus<mpl::_1, segmented_size<remove_reference<mpl::_2> > >
+        >::type
+    {};
+    template<typename Sequence>
+    struct segmented_size_impl<Sequence, false>
+      : result_of::size<Sequence>::type
+    {};
+    template<typename Sequence>
+    struct segmented_size
+      : segmented_size_impl<Sequence>
+    {};
+}}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct size_impl
+        {
+            template<typename Sequence>
+            struct unsegmented_size : Sequence::size {};
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_size<Sequence>
+                  , unsegmented_size<Sequence>
+                >::type
+            {};
+        };
+        template <>
+        struct size_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template size<Sequence> {};
+        };
+        template <>
+        struct size_impl<boost_tuple_tag>;
+        template <>
+        struct size_impl<boost_array_tag>;
+        template <>
+        struct size_impl<mpl_sequence_tag>;
+        template <>
+        struct size_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct size
+            : extension::size_impl<typename detail::tag_of<Sequence>::type>::
+        template apply<Sequence>
+        {
+            typedef typename extension::size_impl<typename detail::tag_of<Sequence>::type>::
+            template apply<Sequence>::type size_application;
+            static const int value = size_application::value;
+        };
+    }
+    template <typename Sequence>
+    inline typename result_of::size<Sequence>::type
+    size(Sequence const&)
+    {
+        typedef typename result_of::size<Sequence>::type result;
+        return result();
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    struct adapt_deref_traits
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename
+                result_of::deref<typename Iterator::first_type>::type
+            type;
+            static type
+            call(Iterator const& i)
+            {
+                return *i.first;
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct joint_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<joint_view_iterator_tag>
+            : detail::adapt_deref_traits {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct joint_view_iterator_tag;
+    template <typename Category, typename First, typename Last, typename Concat>
+    struct joint_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<joint_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename Iterator::last_type last_type;
+                typedef typename Iterator::concat_type concat_type;
+                typedef typename Iterator::category category;
+                typedef typename result_of::next<first_type>::type next_type;
+                typedef result_of::equal_to<next_type, last_type> equal_to;
+                typedef typename
+                    mpl::if_<
+                        equal_to
+                      , concat_type
+                      , joint_view_iterator<category, next_type, last_type, concat_type>
+                    >::type
+                type;
+                static type
+                call(Iterator const& i, mpl::true_)
+                {
+                    return i.concat;
+                }
+                static type
+                call(Iterator const& i, mpl::false_)
+                {
+                    return type(fusion::next(i.first), i.concat);
+                }
+                static type
+                call(Iterator const& i)
+                {
+                    return call(i, equal_to());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    struct adapt_value_traits
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef typename
+                result_of::value_of<typename Iterator::first_type>::type
+            type;
+        };
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct joint_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<joint_view_iterator_tag>
+            : detail::adapt_value_traits {};
+    }
+}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct deref_data_impl;
+    template <>
+    struct deref_data_impl<joint_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+        {
+            typedef typename
+                result_of::deref_data<typename It::first_type>::type
+            type;
+            static type
+            call(It const& it)
+            {
+                return fusion::deref_data(it.first);
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_of_data_impl;
+    template <>
+    struct value_of_data_impl<joint_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::value_of_data<typename It::first_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct key_of_impl;
+    template <>
+    struct key_of_impl<joint_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::key_of<typename It::first_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct joint_view_iterator_tag;
+    struct forward_traversal_tag;
+    template <typename Category, typename First, typename Last, typename Concat>
+    struct joint_view_iterator
+        : iterator_base<joint_view_iterator<Category, First, Last, Concat> >
+    {
+        typedef convert_iterator<First> first_converter;
+        typedef convert_iterator<Last> last_converter;
+        typedef convert_iterator<Concat> concat_converter;
+        typedef typename first_converter::type first_type;
+        typedef typename last_converter::type last_type;
+        typedef typename concat_converter::type concat_type;
+        typedef joint_view_iterator_tag fusion_tag;
+        typedef Category category;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!result_of::equal_to<first_type, last_type>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_41;
+        joint_view_iterator(First const& in_first, Concat const& in_concat)
+            : first(first_converter::call(in_first))
+            , concat(concat_converter::call(in_concat))
+        {}
+        first_type first;
+        concat_type concat;
+    private:
+        joint_view_iterator& operator= (joint_view_iterator const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct joint_view_tag;
+    template <typename Category, typename First, typename Last, typename Concat>
+    struct joint_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<joint_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::first_type first_type;
+                typedef typename Sequence::last_type last_type;
+                typedef typename Sequence::concat_type concat_type;
+                typedef typename Sequence::category category;
+                typedef result_of::equal_to<first_type, last_type> equal_to;
+                typedef typename
+                    mpl::if_<
+                        equal_to
+                      , concat_type
+                      , joint_view_iterator<category, first_type, last_type, concat_type>
+                    >::type
+                type;
+                static type
+                call(Sequence& s, mpl::true_)
+                {
+                    return s.concat();
+                }
+                static type
+                call(Sequence& s, mpl::false_)
+                {
+                    return type(s.first(), s.concat());
+                }
+                static type
+                call(Sequence& s)
+                {
+                    return call(s, equal_to());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct joint_view_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<joint_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::concat_last_type type;
+                static type
+                call(Sequence& s)
+                {
+                    return s.concat_last();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl {
+struct empty_base {};
+template< typename T >
+struct is_empty_base
+    : false_
+{
+};
+template<>
+struct is_empty_base<empty_base>
+    : true_
+{
+};
+}}
+namespace boost {
+template<> struct is_empty< mpl::empty_base > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost { namespace mpl {
+template<
+      typename T1 = na
+    , typename T2 = na
+    >
+struct inherit2
+    : T1, T2
+{
+    typedef inherit2 type;
+};
+template< typename T1 >
+struct inherit2< T1,empty_base >
+{
+    typedef T1 type;
+};
+template< typename T2 >
+struct inherit2< empty_base,T2 >
+{
+    typedef T2 type;
+};
+template<>
+struct inherit2< empty_base,empty_base >
+{
+    typedef empty_base type;
+};
+template<> struct inherit2< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : inherit2< T1 , T2 > { }; }; template< typename Tag > struct lambda< inherit2< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef inherit2< na , na > result_; typedef inherit2< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< inherit2< T1 , T2 > > : int_<2> { }; template<> struct template_arity< inherit2< na , na > > : int_<-1> { }; }
+template<
+      typename T1 = na, typename T2 = na, typename T3 = na
+    >
+struct inherit3
+    : inherit2<
+          typename inherit2<
+              T1, T2
+            >::type
+        , T3
+        >
+{
+};
+template<> struct inherit3< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : inherit3< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< inherit3< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef inherit3< na , na , na > result_; typedef inherit3< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< inherit3< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< inherit3< na , na , na > > : int_<-1> { }; }
+template<
+      typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na
+    >
+struct inherit4
+    : inherit2<
+          typename inherit3<
+              T1, T2, T3
+            >::type
+        , T4
+        >
+{
+};
+template<> struct inherit4< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : inherit4< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< inherit4< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef inherit4< na , na , na , na > result_; typedef inherit4< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< inherit4< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< inherit4< na , na , na , na > > : int_<-1> { }; }
+template<
+      typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na
+    , typename T5 = na
+    >
+struct inherit5
+    : inherit2<
+          typename inherit4<
+              T1, T2, T3, T4
+            >::type
+        , T5
+        >
+{
+};
+template<> struct inherit5< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : inherit5< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< inherit5< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef inherit5< na , na , na , na , na > result_; typedef inherit5< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< inherit5< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< inherit5< na , na , na , na , na > > : int_<-1> { }; }
+template<
+      typename T1 = empty_base, typename T2 = empty_base
+    , typename T3 = empty_base, typename T4 = empty_base
+    , typename T5 = empty_base
+    >
+struct inherit
+    : inherit5< T1,T2,T3,T4,T5 >
+{
+};
+template<>
+struct inherit< na,na,na,na,na >
+{
+    template<
+          typename T1 = empty_base, typename T2 = empty_base
+        , typename T3 = empty_base, typename T4 = empty_base
+        , typename T5 = empty_base
+        >
+    struct apply
+        : inherit< T1,T2,T3,T4,T5 >
+    {
+    };
+};
+template< typename Tag > struct lambda< inherit< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef inherit< na , na , na , na , na > result_; typedef inherit< na , na , na , na , na > type; };
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< inherit< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< inherit< na , na , na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct joint_view_tag;
+    struct forward_traversal_tag;
+    struct fusion_sequence_tag;
+    template <typename Sequence1, typename Sequence2>
+    struct joint_view : sequence_base<joint_view<Sequence1, Sequence2> >
+    {
+        typedef joint_view_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef typename
+            mpl::eval_if<
+                mpl::and_<
+                    traits::is_associative<Sequence1>
+                  , traits::is_associative<Sequence2>
+                >
+              , mpl::inherit2<forward_traversal_tag,associative_tag>
+              , mpl::identity<forward_traversal_tag>
+            >::type
+        category;
+        typedef mpl::true_ is_view;
+        typedef typename result_of::begin<Sequence1>::type first_type;
+        typedef typename result_of::end<Sequence1>::type last_type;
+        typedef typename result_of::begin<Sequence2>::type concat_type;
+        typedef typename result_of::end<Sequence2>::type concat_last_type;
+        typedef typename mpl::int_<
+            result_of::size<Sequence1>::value + result_of::size<Sequence2>::value>
+        size;
+        joint_view(Sequence1& in_seq1, Sequence2& in_seq2)
+            : seq1(in_seq1)
+            , seq2(in_seq2)
+        {}
+        first_type first() const { return fusion::begin(seq1); }
+        concat_type concat() const { return fusion::begin(seq2); }
+        concat_last_type concat_last() const { return fusion::end(seq2); }
+    private:
+        joint_view& operator= (joint_view const&);
+        typename mpl::if_<traits::is_view<Sequence1>, Sequence1, Sequence1&>::type seq1;
+        typename mpl::if_<traits::is_view<Sequence2>, Sequence2, Sequence2&>::type seq2;
+    };
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct equal_to_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct equal_to_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct equal_to_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct equal_to_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct equal_to_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct equal_to
+    : equal_to_impl<
+          typename equal_to_tag<N1>::type
+        , typename equal_to_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct equal_to_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N1::value == N2::value ) >
+    {
+    };
+};
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<single_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                enum { mpl_assertion_in_line_30 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (mpl::equal_to<typename Iterator::position, mpl::int_<0> >))0, 1 ) ) ) };
+                typedef typename Iterator::value_type type;
+                static type
+                call(Iterator const& i)
+                {
+                    return i.view.val;
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    template <typename SingleView, typename Pos>
+    struct single_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<single_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef single_view_iterator<
+                    typename Iterator::single_view_type,
+                    typename mpl::next<typename Iterator::position>::type>
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((type::position::value < 2)) == 0 ? false : true) >)> boost_static_assert_typedef_40;
+                    return type(i.view);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    template <typename Sequence, typename Pos>
+    struct single_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct prior_impl;
+        template <>
+        struct prior_impl<single_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef single_view_iterator<
+                    typename Iterator::single_view_type,
+                    typename mpl::prior<typename Iterator::position>::type>
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.view);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    template <typename SingleView, typename Pos>
+    struct single_view_iterator;
+    namespace extension
+    {
+        template<typename Tag>
+        struct advance_impl;
+        template<>
+        struct advance_impl<single_view_iterator_tag>
+        {
+            template<typename Iterator, typename Dist>
+            struct apply
+            {
+                typedef single_view_iterator<
+                    typename Iterator::single_view_type,
+                    typename mpl::plus<typename Iterator::position, Dist>::type>
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.view);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct minus_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct minus_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct minus_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct minus_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct minus_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct minus
+    : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5>
+{
+};
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct minus< N1,N2,N3,N4,na >
+    : minus< minus< minus< N1,N2 >, N3>, N4>
+{
+};
+template<
+      typename N1, typename N2, typename N3
+    >
+struct minus< N1,N2,N3,na,na >
+    : minus< minus< N1,N2 >, N3>
+{
+};
+template<
+      typename N1, typename N2
+    >
+struct minus< N1,N2,na,na,na >
+    : minus_impl<
+          typename minus_tag<N1>::type
+        , typename minus_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct minus_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  - N2::value
+                )
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct distance_impl;
+        template<>
+        struct distance_impl<single_view_iterator_tag>
+        {
+            template<typename First, typename Last>
+            struct apply
+              : mpl::minus<typename Last::position, typename First::position>
+            {
+                typedef typename mpl::minus<typename Last::position,
+                    typename First::position>::type type;
+                static type
+                call(First const& , Last const& )
+                {
+                    return type();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct equal_to_impl;
+        template<>
+        struct equal_to_impl<single_view_iterator_tag>
+        {
+            template<typename It1, typename It2>
+            struct apply
+              : mpl::equal_to<typename It1::position, typename It2::position>
+            {
+                enum { mpl_assertion_in_line_33 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_same<typename add_const<typename It1::single_view_type>::type, typename add_const<typename It2::single_view_type>::type>))0, 1 ) ) ) }
+                                                                               ;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<single_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                enum { mpl_assertion_in_line_30 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (mpl::equal_to<typename Iterator::position, mpl::int_<0> >))0, 1 ) ) ) };
+                typedef typename Iterator::value_type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_iterator_tag;
+    struct random_access_traversal_tag;
+    template <typename SingleView, typename Pos>
+    struct single_view_iterator
+        : iterator_base<single_view_iterator<SingleView, Pos> >
+    {
+        typedef single_view_iterator_tag fusion_tag;
+        typedef random_access_traversal_tag category;
+        typedef typename SingleView::value_type value_type;
+        typedef Pos position;
+        typedef SingleView single_view_type;
+        explicit single_view_iterator(single_view_type& in_view)
+            : view(in_view) {}
+        SingleView& view;
+    private:
+        single_view_iterator& operator=(single_view_iterator const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct at_impl;
+        template<>
+        struct at_impl<single_view_tag>
+        {
+            template<typename Sequence, typename N>
+            struct apply
+            {
+                enum { mpl_assertion_in_line_30 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (mpl::equal_to<N, mpl::int_<0> >))0, 1 ) ) ) };
+                typedef typename Sequence::value_type type;
+                static type
+                call(Sequence& seq)
+                {
+                    return seq.val;
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    template <typename SingleView, typename Pos>
+    struct single_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<single_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef single_view_iterator<Sequence, mpl::int_<0> > type;
+                static type
+                call(Sequence& seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    template <typename SingleView, typename Pos>
+    struct single_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<single_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef single_view_iterator<Sequence, mpl::int_<1> > type;
+                static type
+                call(Sequence& seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct size_impl;
+        template <>
+        struct size_impl<single_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef mpl::int_<1> type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl
+        {
+            template <typename Sequence, typename N>
+            struct apply;
+        };
+        template <>
+        struct value_at_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply : Sequence::template value_at<Sequence, N> {};
+        };
+        template <>
+        struct value_at_impl<boost_tuple_tag>;
+        template <>
+        struct value_at_impl<boost_array_tag>;
+        template <>
+        struct value_at_impl<mpl_sequence_tag>;
+        template <>
+        struct value_at_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct value_at
+            : extension::value_at_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+        template <typename Sequence, int N>
+        struct value_at_c
+            : fusion::result_of::value_at<Sequence, mpl::int_<N> >
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct value_at_impl;
+        template<>
+        struct value_at_impl<single_view_tag>
+        {
+            template<typename Sequence, typename N>
+            struct apply
+            {
+                enum { mpl_assertion_in_line_31 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (mpl::equal_to<N, mpl::int_<0> >))0, 1 ) ) ) };
+                typedef typename Sequence::value_type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct single_view_tag;
+    struct random_access_traversal_tag;
+    struct fusion_sequence_tag;
+    template <typename T>
+    struct single_view : sequence_base<single_view<T> >
+    {
+        typedef single_view_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef random_access_traversal_tag category;
+        typedef mpl::true_ is_view;
+        typedef mpl::int_<1> size;
+        typedef T value_type;
+        single_view()
+            : val() {}
+        explicit single_view(typename detail::call_param<T>::type in_val)
+            : val(in_val) {}
+        value_type val;
+    };
+    template <typename T>
+    inline single_view<typename detail::as_fusion_element<T>::type>
+    make_single_view(T const& v)
+    {
+        return single_view<typename detail::as_fusion_element<T>::type>(v);
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct push_back
+        {
+            typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view;
+            typedef joint_view<Sequence, single_view const> type;
+        };
+    }
+    template <typename Sequence, typename T>
+    inline typename result_of::push_back<Sequence const, T>::type
+    push_back(Sequence const& seq, T const& x)
+    {
+        typedef typename result_of::push_back<Sequence const, T> push_back;
+        typedef typename push_back::single_view single_view;
+        typedef typename push_back::type result;
+        single_view x_(x);
+        return result(seq, x_);
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct push_front
+        {
+            typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view;
+            typedef joint_view<single_view const, Sequence> type;
+        };
+    }
+    template <typename Sequence, typename T>
+    inline typename result_of::push_front<Sequence const, T>::type
+    push_front(Sequence const& seq, T const& x)
+    {
+        typedef typename result_of::push_front<Sequence const, T> push_front;
+        typedef typename push_front::single_view single_view;
+        typedef typename push_front::type result;
+        single_view x_(x);
+        return result(x_, seq);
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template<typename Cons, typename State = nil>
+    struct reverse_cons;
+    template<typename Car, typename Cdr, typename State>
+    struct reverse_cons<cons<Car, Cdr>, State>
+    {
+        typedef reverse_cons<Cdr, cons<Car, State> > impl;
+        typedef typename impl::type type;
+        static type call(cons<Car, Cdr> const &cons, State const &state = State())
+        {
+            typedef fusion::cons<Car, State> cdr_type;
+            return impl::call(cons.cdr, cdr_type(cons.car, state));
+        }
+    };
+    template<typename State>
+    struct reverse_cons<nil, State>
+    {
+        typedef State type;
+        static State const &call(nil const &, State const &state = State())
+        {
+            return state;
+        }
+    };
+}}}
+namespace boost { namespace fusion { namespace detail
+{
+    struct segment_sequence_tag {};
+    template<typename Sequence>
+    struct segment_sequence
+        : sequence_base<segment_sequence<Sequence> >
+    {
+        typedef fusion_sequence_tag tag;
+        typedef segment_sequence_tag fusion_tag;
+        typedef typename Sequence::is_view is_view;
+        typedef typename Sequence::category category;
+        typedef Sequence sequence_type;
+        sequence_type sequence;
+        explicit segment_sequence(Sequence const & seq)
+            : sequence(seq)
+        {}
+    };
+}
+namespace extension
+{
+    template<typename Tag>
+    struct is_segmented_impl;
+    template<>
+    struct is_segmented_impl<detail::segment_sequence_tag>
+    {
+        template<typename Sequence>
+        struct apply
+            : mpl::true_
+        {};
+    };
+    template<typename Tag>
+    struct segments_impl;
+    template<>
+    struct segments_impl<detail::segment_sequence_tag>
+    {
+        template<typename Sequence>
+        struct apply
+        {
+            typedef typename Sequence::sequence_type type;
+            static type call(Sequence & seq)
+            {
+                return seq.sequence;
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename Last>
+    struct iterator_range;
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct push_back;
+        template <typename Sequence, typename T>
+        struct push_front;
+    }
+    template <typename Sequence, typename T>
+    typename result_of::push_back<Sequence const, T>::type
+    push_back(Sequence const& seq, T const& x);
+    template <typename Sequence, typename T>
+    typename result_of::push_front<Sequence const, T>::type
+    push_front(Sequence const& seq, T const& x);
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Stack, std::size_t Size = Stack::size::value>
+    struct make_segment_sequence_front
+    {
+        enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( result_of::equal_to< typename result_of::end< typename remove_reference< typename add_const< typename result_of::segments< typename remove_reference< typename add_const< typename result_of::deref< typename Stack::car_type::begin_type >::type >::type >::type >::type >::type >::type >::type , typename Stack::cdr_type::car_type::end_type >))0, 1 ) ) ) }
+               ;
+        typedef
+            iterator_range<
+                typename result_of::next<
+                    typename Stack::cdr_type::car_type::begin_type
+                >::type
+              , typename result_of::end<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::segments<
+                                typename remove_reference<
+                                    typename add_const<
+                                        typename result_of::deref<
+                                            typename Stack::car_type::begin_type
+                                        >::type
+                                    >::type
+                                >::type
+                            >::type
+                        >::type
+                    >::type
+                >::type
+            >
+        rest_type;
+        typedef
+            make_segment_sequence_front<typename Stack::cdr_type>
+        recurse;
+        typedef
+            segment_sequence<
+                typename result_of::push_front<
+                    rest_type const
+                  , typename recurse::type
+                >::type
+            >
+        type;
+        static type call(Stack const& stack)
+        {
+            return type(
+                fusion::push_front(
+                    rest_type(fusion::next(stack.cdr.car.first), fusion::end(fusion::segments(*stack.car.first)))
+                  , recurse::call(stack.cdr)));
+        }
+    };
+    template <typename Stack>
+    struct make_segment_sequence_front<Stack, 2>
+    {
+        enum { mpl_assertion_in_line_171 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( result_of::equal_to< typename result_of::end< typename remove_reference< typename add_const< typename result_of::deref< typename Stack::car_type::begin_type >::type >::type >::type >::type , typename Stack::cdr_type::car_type::end_type >))0, 1 ) ) ) }
+               ;
+        typedef
+            iterator_range<
+                typename Stack::cdr_type::car_type::begin_type
+              , typename result_of::end<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::deref<
+                                typename Stack::car_type::begin_type
+                            >::type
+                        >::type
+                    >::type
+                >::type
+            >
+        type;
+        static type call(Stack const& stack)
+        {
+            return type(stack.cdr.car.first, fusion::end(*stack.car.first));
+        }
+    };
+    template <typename Stack>
+    struct make_segment_sequence_front<Stack, 1>
+    {
+        typedef typename Stack::cdr_type type;
+        static type call(Stack const &stack)
+        {
+            return stack.cdr;
+        }
+    };
+    template <typename Stack, std::size_t Size = Stack::size::value>
+    struct make_segment_sequence_back
+    {
+        enum { mpl_assertion_in_line_249 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( result_of::equal_to< typename result_of::end< typename remove_reference< typename add_const< typename result_of::segments< typename remove_reference< typename add_const< typename result_of::deref< typename Stack::car_type::begin_type >::type >::type >::type >::type >::type >::type >::type , typename Stack::cdr_type::car_type::end_type >))0, 1 ) ) ) }
+               ;
+        typedef
+            iterator_range<
+                typename result_of::begin<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::segments<
+                                typename remove_reference<
+                                    typename add_const<
+                                        typename result_of::deref<
+                                            typename Stack::car_type::begin_type
+                                        >::type
+                                    >::type
+                                >::type
+                            >::type
+                        >::type
+                    >::type
+                >::type
+              , typename Stack::cdr_type::car_type::begin_type
+            >
+        rest_type;
+        typedef
+            make_segment_sequence_back<typename Stack::cdr_type>
+        recurse;
+        typedef
+            segment_sequence<
+                typename result_of::push_back<
+                    rest_type const
+                  , typename recurse::type
+                >::type
+            >
+        type;
+        static type call(Stack const& stack)
+        {
+            return type(
+                fusion::push_back(
+                    rest_type(fusion::begin(fusion::segments(*stack.car.first)), stack.cdr.car.first)
+                  , recurse::call(stack.cdr)));
+        }
+    };
+    template <typename Stack>
+    struct make_segment_sequence_back<Stack, 2>
+    {
+        enum { mpl_assertion_in_line_314 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( result_of::equal_to< typename result_of::end< typename remove_reference< typename add_const< typename result_of::deref< typename Stack::car_type::begin_type >::type >::type >::type >::type , typename Stack::cdr_type::car_type::end_type >))0, 1 ) ) ) }
+               ;
+        typedef
+            iterator_range<
+                typename result_of::begin<
+                    typename remove_reference<
+                        typename add_const<
+                            typename result_of::deref<
+                                typename Stack::car_type::begin_type
+                            >::type
+                        >::type
+                    >::type
+                >::type
+              , typename Stack::cdr_type::car_type::begin_type
+            >
+        type;
+        static type call(Stack const& stack)
+        {
+            return type(fusion::begin(*stack.car.first), stack.cdr.car.first);
+        }
+    };
+    template <typename Stack>
+    struct make_segment_sequence_back<Stack, 1>
+    {
+        typedef typename Stack::cdr_type type;
+        static type call(Stack const& stack)
+        {
+            return stack.cdr;
+        }
+    };
+    template <
+        typename StackBegin
+      , typename StackEnd
+      , int StackBeginSize = StackBegin::size::value
+      , int StackEndSize = StackEnd::size::value>
+    struct make_segmented_range_reduce;
+    template <
+        typename StackBegin
+      , typename StackEnd
+      , bool SameSegment =
+            result_of::equal_to<
+                typename StackBegin::car_type::begin_type
+              , typename StackEnd::car_type::begin_type
+            >::type::value>
+    struct make_segmented_range_reduce2
+    {
+        typedef
+            iterator_range<
+                typename result_of::next<
+                    typename StackBegin::car_type::begin_type
+                >::type
+              , typename StackEnd::car_type::begin_type
+            >
+        rest_type;
+        typedef
+            segment_sequence<
+                typename result_of::push_back<
+                    typename result_of::push_front<
+                        rest_type const
+                      , typename make_segment_sequence_front<StackBegin>::type
+                    >::type const
+                  , typename make_segment_sequence_back<StackEnd>::type
+                >::type
+            >
+        type;
+        static type call(StackBegin stack_begin, StackEnd stack_end)
+        {
+            return type(
+                fusion::push_back(
+                    fusion::push_front(
+                        rest_type(fusion::next(stack_begin.car.first), stack_end.car.first)
+                      , make_segment_sequence_front<StackBegin>::call(stack_begin))
+                  , make_segment_sequence_back<StackEnd>::call(stack_end)));
+        }
+    };
+    template <typename StackBegin, typename StackEnd>
+    struct make_segmented_range_reduce2<StackBegin, StackEnd, true>
+    {
+        typedef
+            make_segmented_range_reduce<
+                typename StackBegin::cdr_type
+              , typename StackEnd::cdr_type
+            >
+        impl;
+        typedef
+            typename impl::type
+        type;
+        static type call(StackBegin stack_begin, StackEnd stack_end)
+        {
+            return impl::call(stack_begin.cdr, stack_end.cdr);
+        }
+    };
+    template <typename StackBegin, typename StackEnd, int StackBeginSize, int StackEndSize>
+    struct make_segmented_range_reduce
+      : make_segmented_range_reduce2<StackBegin, StackEnd>
+    {};
+    template <typename StackBegin, typename StackEnd>
+    struct make_segmented_range_reduce<StackBegin, StackEnd, 1, 1>
+    {
+        typedef
+            iterator_range<
+                typename StackBegin::car_type::begin_type
+              , typename StackEnd::car_type::begin_type
+            >
+        range_type;
+        typedef
+            single_view<range_type>
+        segment_type;
+        typedef
+            segment_sequence<segment_type>
+        type;
+        static type call(StackBegin stack_begin, StackEnd stack_end)
+        {
+            return type(segment_type(range_type(stack_begin.car.first, stack_end.car.first)));
+        }
+    };
+    template <typename Begin, typename End>
+    struct make_segmented_range
+    {
+        typedef reverse_cons<typename Begin::context_type> reverse_begin_cons;
+        typedef reverse_cons<typename End::context_type> reverse_end_cons;
+        typedef
+            make_segmented_range_reduce<
+                typename reverse_begin_cons::type
+              , typename reverse_end_cons::type
+            >
+        impl;
+        typedef typename impl::type type;
+        static type call(Begin const& begin, End const& end)
+        {
+            return impl::call(
+                reverse_begin_cons::call(begin.context)
+              , reverse_end_cons::call(end.context));
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct segments_impl;
+        template <>
+        struct segments_impl<iterator_range_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef
+                    detail::make_segmented_range<
+                        typename Sequence::begin_type
+                      , typename Sequence::end_type
+                    >
+                impl;
+                enum { mpl_assertion_in_line_37 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (traits::is_segmented<typename impl::type>))0, 1 ) ) ) };
+                typedef
+                    typename result_of::segments<typename impl::type>::type
+                type;
+                static type call(Sequence & seq)
+                {
+                    return fusion::segments(impl::call(seq.first, seq.last));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct iterator_range_tag;
+    struct fusion_sequence_tag;
+    template <typename First, typename Last>
+    struct iterator_range : sequence_base<iterator_range<First, Last> >
+    {
+        typedef typename convert_iterator<First>::type begin_type;
+        typedef typename convert_iterator<Last>::type end_type;
+        typedef iterator_range_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::true_ is_view;
+        typedef typename traits::category_of<begin_type>::type category;
+        iterator_range(First const& in_first, Last const& in_last)
+            : first(convert_iterator<First>::call(in_first))
+            , last(convert_iterator<Last>::call(in_last)) {}
+        begin_type first;
+        end_type last;
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct empty_impl
+        {
+            template <typename Sequence>
+            struct apply
+                : mpl::bool_<(result_of::size<Sequence>::value == 0)>
+            {};
+        };
+        template <>
+        struct empty_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template empty<Sequence> {};
+        };
+        template <>
+        struct empty_impl<mpl_sequence_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct empty
+            : extension::empty_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+    template <typename Sequence>
+    inline typename result_of::empty<Sequence>::type
+    empty(Sequence const&)
+    {
+        typedef typename result_of::empty<Sequence>::type result;
+        return result();
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<cons_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::cons_type cons_type;
+                typedef typename cons_type::car_type value_type;
+                typedef typename mpl::eval_if<
+                    is_const<cons_type>
+                  , add_reference<typename add_const<value_type>::type>
+                  , add_reference<value_type> >::type
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return i.cons.car;
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_iterator_tag;
+    template <typename Cons>
+    struct cons_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<cons_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::cons_type cons_type;
+                typedef typename cons_type::cdr_type cdr_type;
+                typedef cons_iterator<
+                    typename mpl::eval_if<
+                        is_const<cons_type>
+                      , add_const<cdr_type>
+                      , mpl::identity<cdr_type>
+                    >::type>
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.cons.cdr);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<cons_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::cons_type cons_type;
+                typedef typename cons_type::car_type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct equal_to_impl;
+        template <>
+        struct equal_to_impl<cons_iterator_tag>
+        {
+            template <typename I1, typename I2>
+            struct apply
+                : is_same<
+                    typename I1::identity
+                  , typename I2::identity
+                >
+            {
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    template <
+        typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
+    >
+    struct list;
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    struct cons_iterator_tag;
+    struct forward_traversal_tag;
+    template <typename Cons>
+    struct cons_iterator_identity;
+    template <typename Cons = nil>
+    struct cons_iterator : iterator_base<cons_iterator<Cons> >
+    {
+        typedef cons_iterator_tag fusion_tag;
+        typedef forward_traversal_tag category;
+        typedef Cons cons_type;
+        typedef cons_iterator_identity<
+            typename add_const<Cons>::type>
+        identity;
+        explicit cons_iterator(cons_type& in_cons)
+            : cons(in_cons) {}
+        cons_type& cons;
+    private:
+        cons_iterator& operator= (cons_iterator const&);
+    };
+    struct nil_iterator : iterator_base<nil_iterator>
+    {
+        typedef forward_traversal_tag category;
+        typedef cons_iterator_tag fusion_tag;
+        typedef nil cons_type;
+        typedef cons_iterator_identity<
+            add_const<nil>::type>
+        identity;
+        nil_iterator() {}
+        explicit nil_iterator(nil const&) {}
+    };
+    template <>
+    struct cons_iterator<nil> : nil_iterator
+    {
+        cons_iterator() {}
+        explicit cons_iterator(nil const&) {}
+    };
+    template <>
+    struct cons_iterator<nil const> : nil_iterator
+    {
+        cons_iterator() {}
+        explicit cons_iterator(nil const&) {}
+    };
+    template <>
+    struct cons_iterator<list<> > : nil_iterator
+    {
+        cons_iterator() {}
+        explicit cons_iterator(nil const&) {}
+    };
+    template <>
+    struct cons_iterator<list<> const> : nil_iterator
+    {
+        cons_iterator() {}
+        explicit cons_iterator(nil const&) {}
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    struct cons_tag;
+    template <typename Car, typename Cdr>
+    struct cons;
+    template <typename Cons>
+    struct cons_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<cons_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef cons_iterator<Sequence> type;
+                static type
+                call(Sequence& t)
+                {
+                    return type(t);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct nil;
+    struct cons_tag;
+    template <typename Car, typename Cdr>
+    struct cons;
+    template <typename Cons>
+    struct cons_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<cons_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef cons_iterator<
+                    typename mpl::if_<is_const<Sequence>, nil const, nil>::type>
+                type;
+                static type
+                call(Sequence&)
+                {
+                    return type();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Cons>
+        struct cons_deref
+        {
+            typedef typename Cons::car_type type;
+        };
+        template <typename Cons, int I>
+        struct cons_advance
+        {
+            typedef typename
+                cons_advance<Cons, I-1>::type::cdr_type
+            type;
+        };
+        template <typename Cons>
+        struct cons_advance<Cons, 0>
+        {
+            typedef Cons type;
+        };
+        template <typename Cons>
+        struct cons_advance<Cons, 1>
+        {
+            typedef typename Cons::cdr_type type;
+        };
+        template <typename Cons>
+        struct cons_advance<Cons, 2>
+        {
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type type;
+        };
+        template <typename Cons>
+        struct cons_advance<Cons, 3>
+        {
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type _b;
+            typedef typename _b::cdr_type type;
+        };
+        template <typename Cons>
+        struct cons_advance<Cons, 4>
+        {
+            typedef typename Cons::cdr_type _a;
+            typedef typename _a::cdr_type _b;
+            typedef typename _b::cdr_type _c;
+            typedef typename _c::cdr_type type;
+        };
+    }
+    struct cons_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+        template <>
+        struct at_impl<cons_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef detail::cons_deref<
+                    typename detail::cons_advance<Sequence, N::value>::type>
+                element;
+                typedef typename
+                    mpl::eval_if<
+                        is_const<Sequence>
+                      , detail::cref_result<element>
+                      , detail::ref_result<element>
+                    >::type
+                type;
+                template <typename Cons, int N2>
+                static type
+                call(Cons& s, mpl::int_<N2>)
+                {
+                    return call(s.cdr, mpl::int_<N2-1>());
+                }
+                template <typename Cons>
+                static type
+                call(Cons& s, mpl::int_<0>)
+                {
+                    return s.car;
+                }
+                static type
+                call(Sequence& s)
+                {
+                    return call(s, mpl::int_<N::value>());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl;
+        template <>
+        struct value_at_impl<cons_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef typename
+                    mpl::eval_if<
+                        mpl::bool_<N::value == 0>
+                      , mpl::identity<typename Sequence::car_type>
+                      , apply<typename Sequence::cdr_type, mpl::int_<N::value-1> >
+                    >::type
+                type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct cons_tag;
+    struct nil;
+    template <typename Car, typename Cdr>
+    struct cons;
+    namespace extension
+    {
+        template <typename Tag>
+        struct empty_impl;
+        template <>
+        struct empty_impl<cons_tag>
+        {
+            template <typename Sequence>
+            struct apply
+                : boost::is_convertible<Sequence, nil>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct cons_tag;
+    struct forward_traversal_tag;
+    struct fusion_sequence_tag;
+    struct nil : sequence_base<nil>
+    {
+        typedef mpl::int_<0> size;
+        typedef cons_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef forward_traversal_tag category;
+        typedef void_ car_type;
+        typedef void_ cdr_type;
+        nil() {}
+        template <typename Iterator>
+        nil(Iterator const& , mpl::true_ )
+        {}
+        template <typename Iterator>
+        void assign_from_iter(Iterator const& )
+        {
+        }
+    };
+    template <typename Car, typename Cdr >
+    struct cons : sequence_base<cons<Car, Cdr> >
+    {
+        typedef mpl::int_<Cdr::size::value+1> size;
+        typedef cons_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef forward_traversal_tag category;
+        typedef Car car_type;
+        typedef Cdr cdr_type;
+        cons()
+            : car(), cdr() {}
+        explicit cons(typename detail::call_param<Car>::type in_car)
+            : car(in_car), cdr() {}
+        cons(
+            typename detail::call_param<Car>::type in_car
+          , typename detail::call_param<Cdr>::type in_cdr)
+            : car(in_car), cdr(in_cdr) {}
+        template <typename Car2, typename Cdr2>
+        cons(cons<Car2, Cdr2> const& rhs)
+            : car(rhs.car), cdr(rhs.cdr) {}
+        cons(cons const& rhs)
+            : car(rhs.car), cdr(rhs.cdr) {}
+        template <typename Sequence>
+        cons(
+            Sequence const& seq
+          , typename boost::disable_if<
+                mpl::or_<
+                    is_convertible<Sequence, cons>
+                  , is_convertible<Sequence, Car>
+                >
+            >::type* = 0
+        )
+            : car(*fusion::begin(seq))
+            , cdr(fusion::next(fusion::begin(seq)), mpl::true_()) {}
+        template <typename Iterator>
+        cons(Iterator const& iter, mpl::true_ )
+            : car(*iter)
+            , cdr(fusion::next(iter), mpl::true_()) {}
+        template <typename Car2, typename Cdr2>
+        cons& operator=(cons<Car2, Cdr2> const& rhs)
+        {
+            car = rhs.car;
+            cdr = rhs.cdr;
+            return *this;
+        }
+        cons& operator=(cons const& rhs)
+        {
+            car = rhs.car;
+            cdr = rhs.cdr;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, Car>, cons&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type Iterator;
+            Iterator iter = fusion::begin(seq);
+            this->assign_from_iter(iter);
+            return *this;
+        }
+        template <typename Iterator>
+        void assign_from_iter(Iterator const& iter)
+        {
+            car = *iter;
+            cdr.assign_from_iter(fusion::next(iter));
+        }
+        car_type car;
+        cdr_type cdr;
+    };
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Sequence, typename Nil = fusion::nil>
+    struct segmented_begin
+    {
+        typedef
+            segmented_iterator<
+                typename segmented_begin_impl<Sequence, Nil>::type
+            >
+        type;
+        static type call(Sequence& seq)
+        {
+            return type(
+                segmented_begin_impl<Sequence, Nil>::call(seq, Nil()));
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_begin<Sequence>
+                  , blank
+                >::type
+            {};
+        };
+        template <>
+        struct begin_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template begin<Sequence> {};
+        };
+        template <>
+        struct begin_impl<boost_tuple_tag>;
+        template <>
+        struct begin_impl<boost_array_tag>;
+        template <>
+        struct begin_impl<mpl_sequence_tag>;
+        template <>
+        struct begin_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct begin
+            : extension::begin_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence>
+        >::type const
+    begin(Sequence& seq)
+    {
+        return result_of::begin<Sequence>::call(seq);
+    }
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::begin<Sequence const>
+        >::type const
+    begin(Sequence const& seq)
+    {
+        return result_of::begin<Sequence const>::call(seq);
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Sequence, typename Nil = fusion::nil>
+    struct segmented_end
+    {
+        typedef
+            segmented_iterator<
+                typename segmented_end_impl<Sequence, Nil>::type
+            >
+        type;
+        static type call(Sequence & seq)
+        {
+            return type(
+                segmented_end_impl<Sequence, Nil>::call(seq, Nil()));
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_tuple_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl
+        {
+            template <typename Sequence>
+            struct apply
+              : mpl::if_<
+                    traits::is_segmented<Sequence>
+                  , detail::segmented_end<Sequence>
+                  , blank
+                >::type
+            {};
+        };
+        template <>
+        struct end_impl<sequence_facade_tag>
+        {
+            template <typename Sequence>
+            struct apply : Sequence::template end<Sequence> {};
+        };
+        template <>
+        struct end_impl<boost_tuple_tag>;
+        template <>
+        struct end_impl<boost_array_tag>;
+        template <>
+        struct end_impl<mpl_sequence_tag>;
+        template <>
+        struct end_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct end
+            : extension::end_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence>
+        {};
+    }
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence>
+        >::type const
+    end(Sequence& seq)
+    {
+        return result_of::end<Sequence>::call(seq);
+    }
+    template <typename Sequence>
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::end<Sequence const>
+        >::type const
+    end(Sequence const& seq)
+    {
+        return result_of::end<Sequence const>::call(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct fusion_sequence_tag;
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct back
+            : result_of::deref<typename result_of::prior<typename result_of::end<Sequence>::type>::type>
+        {};
+    }
+    template <typename Sequence>
+    inline typename result_of::back<Sequence>::type
+    back(Sequence& seq)
+    {
+        return *fusion::prior(fusion::end(seq));
+    }
+    template <typename Sequence>
+    inline typename result_of::back<Sequence const>::type
+    back(Sequence const& seq)
+    {
+        return *fusion::prior(fusion::end(seq));
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct fusion_sequence_tag;
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct front
+            : result_of::deref<typename result_of::begin<Sequence>::type>
+        {};
+    }
+    template <typename Sequence>
+    inline typename result_of::front<Sequence>::type
+    front(Sequence& seq)
+    {
+        return *fusion::begin(seq);
+    }
+    template <typename Sequence>
+    inline typename result_of::front<Sequence const>::type
+    front(Sequence const& seq)
+    {
+        return *fusion::begin(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if;
+    }
+    template <typename Pred, typename Sequence>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq);
+    template <typename Pred, typename Sequence>
+    typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq);
+}}
+namespace boost { namespace fusion {
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename Iterator, typename Pred>
+    struct apply_filter
+    {
+        typedef typename mpl::apply1<
+            Pred, Iterator>::type type;
+        static const int value = type::value;
+    };
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if;
+    template <typename First, typename Last, typename Pred>
+    struct recursive_find_if
+    {
+        typedef typename
+            main_find_if<
+                typename result_of::next<First>::type, Last, Pred
+            >::type
+        type;
+    };
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if
+    {
+        typedef mpl::or_<
+            result_of::equal_to<First, Last>
+          , apply_filter<First, Pred> >
+        filter;
+        typedef typename
+            mpl::eval_if<
+                filter
+              , mpl::identity<First>
+              , recursive_find_if<First, Last, Pred>
+            >::type
+        type;
+    };
+    template<
+        typename First, typename Last,
+        typename Pred, bool>
+    struct choose_find_if;
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, false>
+        : main_find_if<First, Last, Pred>
+    {};
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again;
+    template <typename Iter, typename Pred, int offset>
+    struct apply_offset_filter
+    {
+        typedef typename result_of::advance_c<Iter, offset>::type Shifted;
+        typedef typename
+            mpl::apply1<
+                Pred
+              , Shifted
+            >::type
+        type;
+        static const int value = type::value;
+    };
+    template<typename Iter, typename Pred, int n>
+    struct unrolled_find_if
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                mpl::eval_if<
+                  apply_offset_filter<Iter, Pred, 3>,
+                  result_of::advance_c<Iter, 3>,
+                  unroll_again<
+                    Iter,
+                    Pred,
+                    n,
+                    4> > > > >::type type;
+    };
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 3>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                result_of::advance_c<Iter, 3> > > >::type type;
+    };
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 2>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              result_of::advance_c<Iter, 2> > >::type type;
+    };
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 1>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            result_of::advance_c<Iter, 1> >::type type;
+    };
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again
+    {
+        typedef typename unrolled_find_if<
+            typename result_of::advance_c<Iter, unrolling>::type,
+            Pred,
+            n-unrolling>::type type;
+    };
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 0>
+    {
+        typedef Iter type;
+    };
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, true>
+    {
+        typedef typename result_of::distance<First, Last>::type N;
+        typedef typename unrolled_find_if<First, Pred, N::value>::type type;
+    };
+    template <typename First, typename Last, typename Pred>
+    struct static_find_if
+    {
+        typedef typename
+            choose_find_if<
+                First
+              , Last
+              , typename mpl::lambda<Pred>::type
+              , is_base_of<random_access_traversal_tag, typename traits::category_of<First>::type>::value
+            >::type
+        type;
+        template <typename Iterator>
+        static type
+        recursive_call(Iterator const& iter, mpl::true_)
+        {
+            return iter;
+        }
+        template <typename Iterator>
+        static type
+        recursive_call(Iterator const& iter, mpl::false_)
+        {
+            return recursive_call(fusion::next(iter));
+        }
+        template <typename Iterator>
+        static type
+        recursive_call(Iterator const& iter)
+        {
+            typedef result_of::equal_to<Iterator, type> found;
+            return recursive_call(iter, found());
+        }
+        template <typename Iterator, typename Tag>
+        static type
+        choose_call(Iterator const& iter, Tag)
+        {
+            return recursive_call(iter);
+        }
+        template <typename Iterator>
+        static type
+        choose_call(Iterator const& iter, random_access_traversal_tag)
+        {
+            typedef typename result_of::distance<Iterator, type>::type N;
+            return fusion::advance<N>(iter);
+        }
+        template <typename Iterator>
+        static type
+        iter_call(Iterator const& iter)
+        {
+            return choose_call(iter, typename traits::category_of<Iterator>::type());
+        }
+        template <typename Sequence>
+        static type
+        call(Sequence& seq)
+        {
+            return iter_call(fusion::begin(seq));
+        }
+    };
+    template <typename Sequence, typename Pred>
+    struct result_of_find_if
+    {
+        typedef
+            static_find_if<
+                typename result_of::begin<Sequence>::type
+              , typename result_of::end<Sequence>::type
+              , Pred
+            >
+        filter;
+        typedef typename filter::type type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find;
+    }
+    template <typename T, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq);
+    template <typename T, typename Sequence>
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq);
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename State, typename Fun>
+        struct segmented_fold_until
+        {
+            typedef
+                detail::segmented_fold_until_impl<
+                    Sequence
+                  , State
+                  , fusion::nil
+                  , Fun
+                >
+            filter;
+            typedef
+                typename filter::type
+            type;
+        };
+    }
+    template <typename Sequence, typename State, typename Fun>
+    typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::segmented_fold_until<Sequence, State, Fun>
+        >::type
+    segmented_fold_until(Sequence& seq, State const& state, Fun const& fun)
+    {
+        typedef
+            typename result_of::segmented_fold_until<Sequence, State, Fun>::filter
+        filter;
+        return filter::call(seq, state, fusion::nil(), fun);
+    }
+    template <typename Sequence, typename State, typename Fun>
+    typename result_of::segmented_fold_until<Sequence const, State, Fun>::type
+    segmented_fold_until(Sequence const& seq, State const& state, Fun const& fun)
+    {
+        typedef
+            typename result_of::segmented_fold_until<Sequence const, State, Fun>::filter
+        filter;
+        return filter::call(seq, state, fusion::nil(), fun);
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct segmented_find_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                typename result_of::find<Sequence, T>::type
+            iterator_type;
+            typedef
+                typename result_of::equal_to<
+                    iterator_type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            continue_type;
+            typedef
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
+            {
+                return call_impl(seq, state, context, continue_type());
+            }
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
+            {
+                return state;
+            }
+            static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_)
+            {
+                return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
+            }
+        };
+    };
+    template <typename Sequence, typename T>
+    struct result_of_segmented_find
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_fun<T>
+                >::type
+            type;
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , detail::segmented_find_fun<T>());
+            }
+        };
+        typedef typename filter::type type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find<Sequence, T>
+              , detail::result_of_find_if<
+                    Sequence,
+                    is_same<
+                        typename mpl::if_<
+                            traits::is_associative<Sequence>
+                          , key_of<mpl::_1>
+                          , value_of<mpl::_1>
+                        >::type
+                      , T
+                    >
+                >
+            >::type
+        {};
+    }
+    template <typename T, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq)
+    {
+        typedef typename result_of::find<Sequence, T>::filter filter;
+        return filter::call(seq);
+    }
+    template <typename T, typename Sequence>
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq)
+    {
+        typedef typename result_of::find<Sequence const, T>::filter filter;
+        return filter::call(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct sequence_facade_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct has_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+              : mpl::not_<
+                    typename result_of::equal_to<
+                        typename result_of::find<Seq, Key>::type
+                      , typename result_of::end<Seq>::type
+                    >::type
+                >::type
+            {};
+        };
+        template <>
+        struct has_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template has_key<Sequence, Key> {};
+        };
+        template <>
+        struct has_key_impl<boost_array_tag>;
+        template <>
+        struct has_key_impl<mpl_sequence_tag>;
+        template <>
+        struct has_key_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct has_key
+            : extension::has_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, Key>
+        {};
+    }
+    template <typename Key, typename Sequence>
+    inline typename result_of::has_key<Sequence, Key>::type
+    has_key(Sequence const& seq)
+    {
+        typedef typename result_of::has_key<Sequence, Key>::type result;
+        return result();
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+            {
+                typedef typename
+                    result_of::deref_data<
+                        typename result_of::find<Seq, Key>::type
+                    >::type
+                type;
+                static type
+                call(Seq& seq)
+                {
+                    return fusion::deref_data(fusion::find<Key>(seq));
+                }
+            };
+        };
+        template <>
+        struct at_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template at_key_impl<Sequence, Key> {};
+        };
+        template <>
+        struct at_key_impl<boost_array_tag>;
+        template <>
+        struct at_key_impl<mpl_sequence_tag>;
+        template <>
+        struct at_key_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct at_key
+            : extension::at_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, Key>
+        {};
+    }
+    template <typename Key, typename Sequence>
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::at_key<Sequence, Key>
+        >::type
+    at_key(Sequence& seq)
+    {
+        return result_of::at_key<Sequence, Key>::call(seq);
+    }
+    template <typename Key, typename Sequence>
+    inline typename result_of::at_key<Sequence const, Key>::type
+    at_key(Sequence const& seq)
+    {
+        return result_of::at_key<Sequence const, Key>::call(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct sequence_facade_tag;
+    struct boost_array_tag;
+    struct mpl_sequence_tag;
+    struct std_pair_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_key_impl
+        {
+            template <typename Seq, typename Key>
+            struct apply
+              : result_of::value_of_data<
+                    typename result_of::find<Seq, Key>::type
+                >
+            {};
+        };
+        template <>
+        struct value_at_key_impl<sequence_facade_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : Sequence::template value_at_key<Sequence, Key> {};
+        };
+        template <>
+        struct value_at_key_impl<boost_array_tag>;
+        template <>
+        struct value_at_key_impl<mpl_sequence_tag>;
+        template <>
+        struct value_at_key_impl<std_pair_tag>;
+    }
+    namespace result_of
+    {
+        template <typename Sequence, typename N>
+        struct value_at_key
+            : extension::value_at_key_impl<typename detail::tag_of<Sequence>::type>::
+                template apply<Sequence, N>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace detail
+    {
+        template <typename F>
+        struct apply_transform_result
+        {
+            template <typename T0, typename T1 = void_>
+            struct apply
+                : boost::result_of<F(T0, T1)>
+            {};
+            template <typename T0>
+            struct apply<T0, void_>
+                : boost::result_of<F(T0)>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<transform_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::deref<typename Iterator::first_type>::type
+                value_type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
+                static type
+                call(Iterator const& i)
+                {
+                    return i.f(*i.first);
+                }
+            };
+        };
+        template <>
+        struct deref_impl<transform_view_iterator2_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::deref<typename Iterator::first1_type>::type
+                value1_type;
+                typedef typename
+                    result_of::deref<typename Iterator::first2_type>::type
+                value2_type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+                static type
+                call(Iterator const& i)
+                {
+                    return i.f(*i.first1, *i.first2);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    template<typename First, typename F>
+    struct transform_view_iterator;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<transform_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename result_of::next<first_type>::type next_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator<next_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(fusion::next(i.first), i.f);
+                }
+            };
+        };
+        template <>
+        struct next_impl<transform_view_iterator2_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first1_type first1_type;
+                typedef typename Iterator::first2_type first2_type;
+                typedef typename result_of::next<first1_type>::type next1_type;
+                typedef typename result_of::next<first2_type>::type next2_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator2<next1_type, next2_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(fusion::next(i.first1), fusion::next(i.first2), i.f);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    template<typename First, typename F>
+    struct transform_view_iterator;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2;
+    namespace extension
+    {
+        template<typename Tag>
+        struct prior_impl;
+        template<>
+        struct prior_impl<transform_view_iterator_tag>
+        {
+            template<typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename result_of::prior<first_type>::type prior_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator<prior_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(fusion::prior(i.first), i.f);
+                }
+            };
+        };
+        template<>
+        struct prior_impl<transform_view_iterator2_tag>
+        {
+            template<typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first1_type first1_type;
+                typedef typename Iterator::first2_type first2_type;
+                typedef typename result_of::prior<first1_type>::type prior1_type;
+                typedef typename result_of::prior<first2_type>::type prior2_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator2<prior1_type, prior2_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(fusion::prior(i.first1), fusion::prior(i.first2), i.f);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<transform_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::value_of<typename Iterator::first_type>::type
+                value_type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
+            };
+        };
+        template <>
+        struct value_of_impl<transform_view_iterator2_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::value_of<typename Iterator::first1_type>::type
+                value1_type;
+                typedef typename
+                    result_of::value_of<typename Iterator::first2_type>::type
+                value2_type;
+                typedef detail::apply_transform_result<typename Iterator::transform_type> transform_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    template<typename First, typename F>
+    struct transform_view_iterator;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2;
+    namespace extension
+    {
+        template<typename Tag>
+        struct advance_impl;
+        template<>
+        struct advance_impl<transform_view_iterator_tag>
+        {
+            template<typename Iterator, typename Dist>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename result_of::advance<first_type, Dist>::type advanced_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator<advanced_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(boost::fusion::advance<Dist>(i.first), i.f);
+                }
+            };
+        };
+        template<>
+        struct advance_impl<transform_view_iterator2_tag>
+        {
+            template<typename Iterator, typename Dist>
+            struct apply
+            {
+                typedef typename Iterator::first1_type first1_type;
+                typedef typename Iterator::first2_type first2_type;
+                typedef typename result_of::advance<first1_type, Dist>::type advanced1_type;
+                typedef typename result_of::advance<first2_type, Dist>::type advanced2_type;
+                typedef typename Iterator::transform_type transform_type;
+                typedef transform_view_iterator2<advanced1_type, advanced2_type, transform_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(
+                        boost::fusion::advance<Dist>(i.first1)
+                      , boost::fusion::advance<Dist>(i.first2), i.f);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct distance_impl;
+        template<>
+        struct distance_impl<transform_view_iterator_tag>
+        {
+            template<typename First, typename Last>
+            struct apply
+                : result_of::distance<typename First::first_type, typename Last::first_type>
+            {
+                static
+                typename result_of::distance<typename First::first_type, typename Last::first_type>::type
+                call(First const& first, Last const& last)
+                {
+                    return boost::fusion::distance(first.first, last.first);
+                }
+            };
+        };
+        template<>
+        struct distance_impl<transform_view_iterator2_tag>
+        {
+            template<typename First, typename Last>
+            struct apply
+                : result_of::distance<typename First::first1_type, typename Last::first1_type>
+            {
+                static
+                typename result_of::distance<typename First::first1_type, typename Last::first1_type>::type
+                call(First const& first, Last const& last)
+                {
+                    return boost::fusion::distance(first.first1, last.first1);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct transform_view_iterator_tag;
+    struct transform_view_iterator2_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct equal_to_impl;
+        template<>
+        struct equal_to_impl<transform_view_iterator_tag>
+        {
+            template<typename It1, typename It2>
+            struct apply
+                : result_of::equal_to<typename It1::first_type, typename It2::first_type>
+            {};
+        };
+        template<>
+        struct equal_to_impl<transform_view_iterator2_tag>
+        {
+            template<typename It1, typename It2>
+            struct apply
+                : result_of::equal_to<typename It1::first1_type, typename It2::first1_type>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct transform_view_iterator_tag;
+    template <typename First, typename F>
+    struct transform_view_iterator
+        : iterator_base<transform_view_iterator<First, F> >
+    {
+        typedef transform_view_iterator_tag fusion_tag;
+        typedef convert_iterator<First> converter;
+        typedef typename converter::type first_type;
+        typedef typename traits::category_of<first_type>::type category;
+        typedef F transform_type;
+        transform_view_iterator(First const& in_first, F const& in_f)
+            : first(converter::call(in_first)), f(in_f) {}
+        first_type first;
+        transform_type f;
+    private:
+        transform_view_iterator& operator= (transform_view_iterator const&);
+    };
+    struct transform_view_iterator2_tag;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2
+        : iterator_base<transform_view_iterator2<First1, First2, F> >
+    {
+        typedef transform_view_iterator2_tag fusion_tag;
+        typedef convert_iterator<First1> converter1;
+        typedef convert_iterator<First2> converter2;
+        typedef typename converter1::type first1_type;
+        typedef typename converter2::type first2_type;
+        typedef typename traits::category_of<first1_type>::type category;
+        typedef F transform_type;
+        transform_view_iterator2(First1 const& in_first1, First2 const& in_first2, F const& in_f)
+            : first1(converter1::call(in_first1)), first2(converter2::call(in_first2)), f(in_f) {}
+        first1_type first1;
+        first2_type first2;
+        transform_type f;
+    private:
+        transform_view_iterator2& operator= (transform_view_iterator2 const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct transform_view_tag;
+    struct transform_view2_tag;
+    template <typename A, typename B, typename C = void_>
+    struct transform_view;
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename F>
+    struct transform_view_iterator;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<transform_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::first_type first_type;
+                typedef typename Sequence::transform_type transform_type;
+                typedef transform_view_iterator<first_type, transform_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.first(), s.f);
+                }
+            };
+        };
+        template <>
+        struct begin_impl<transform_view2_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::first1_type first1_type;
+                typedef typename Sequence::first2_type first2_type;
+                typedef typename Sequence::transform_type transform_type;
+                typedef transform_view_iterator2<first1_type, first2_type, transform_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.first1(), s.first2(), s.f);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    template <typename First, typename F>
+    struct transform_view_iterator;
+    template <typename First1, typename First2, typename F>
+    struct transform_view_iterator2;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<transform_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::last_type last_type;
+                typedef typename Sequence::transform_type transform_type;
+                typedef transform_view_iterator<last_type, transform_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.last(), s.f);
+                }
+            };
+        };
+        template <>
+        struct end_impl<transform_view2_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::last1_type last1_type;
+                typedef typename Sequence::last2_type last2_type;
+                typedef typename Sequence::transform_type transform_type;
+                typedef transform_view_iterator2<last1_type, last2_type, transform_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.last1(), s.last2(), s.f);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct transform_view_tag;
+    struct transform_view2_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct at_impl;
+        template<>
+        struct at_impl<transform_view_tag>
+        {
+            template<typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::transform_type F;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
+                static type call(Seq& seq)
+                {
+                    return seq.f(boost::fusion::at<N>(seq.seq));
+                }
+            };
+        };
+        template<>
+        struct at_impl<transform_view2_tag>
+        {
+            template<typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::transform_type F;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence1_type, N>::type value1_type;
+                typedef typename boost::fusion::result_of::at<typename Seq::sequence2_type, N>::type value2_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+                static type call(Seq& seq)
+                {
+                    return seq.f(boost::fusion::at<N>(seq.seq1), boost::fusion::at<N>(seq.seq2));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct transform_view_tag;
+    struct transform_view2_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct value_at_impl;
+        template<>
+        struct value_at_impl<transform_view_tag>
+        {
+            template<typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::transform_type F;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence_type, N>::type value_type;
+                typedef typename mpl::apply<transform_type, value_type>::type type;
+            };
+        };
+        template<>
+        struct value_at_impl<transform_view2_tag>
+        {
+            template<typename Seq, typename N>
+            struct apply
+            {
+                typedef typename Seq::transform_type F;
+                typedef detail::apply_transform_result<F> transform_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence1_type, N>::type value1_type;
+                typedef typename boost::fusion::result_of::value_at<typename Seq::sequence2_type, N>::type value2_type;
+                typedef typename mpl::apply<transform_type, value1_type, value2_type>::type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_sequence_impl;
+        template<>
+        struct is_sequence_impl<mpl_sequence_tag>
+        {
+            template<typename T>
+            struct apply : mpl::true_ {};
+        };
+    }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct size_impl;
+template< typename Sequence > struct size;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct size_impl
+{
+    template< typename Sequence > struct apply
+        : distance<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+    };
+};
+ template<> struct size_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct size
+    : aux::msvc_eti_base<
+        typename size_impl< typename sequence_tag<Sequence>::type >
+            ::template apply< Sequence >::type
+      >::type
+{
+};
+template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct size_impl;
+        template <>
+        struct size_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence>
+            struct apply : mpl::size<Sequence> {};
+        };
+    }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct at_impl;
+template< typename Sequence, typename N > struct at;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct at_impl
+{
+    template< typename Sequence, typename N > struct apply
+    {
+        typedef typename advance<
+              typename begin<Sequence>::type
+            , N
+            >::type iter_;
+        typedef typename deref<iter_>::type type;
+    };
+};
+ template<> struct at_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename N = na
+    >
+struct at
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,N >
+{
+};
+template<
+      typename Sequence
+    , long N
+    >
+struct at_c
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,mpl::long_<N> >
+{
+};
+template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl;
+        template <>
+        struct value_at_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply : mpl::at<Sequence, N> {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct at_impl;
+        template <>
+        struct at_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef typename mpl::at<Sequence, N>::type type;
+                static type
+                call(Sequence)
+                {
+                    return type();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct has_key_impl;
+template< typename AssociativeSequence, typename Key > struct has_key;
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct has_key_impl
+{
+    template< typename AssociativeSequence, typename Key > struct apply;
+};
+ template<> struct has_key_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename AssociativeSequence = na
+    , typename Key = na
+    >
+struct has_key
+    : has_key_impl< typename sequence_tag<AssociativeSequence>::type >
+        ::template apply<AssociativeSequence,Key>
+{
+};
+template<> struct has_key< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_key< T1 , T2 > { }; }; template< typename Tag > struct lambda< has_key< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_key< na , na > result_; typedef has_key< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< has_key< T1 , T2 > > : int_<2> { }; template<> struct template_arity< has_key< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct has_key_impl;
+        template <>
+        struct has_key_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence, typename Key>
+            struct apply : mpl::has_key<Sequence, Key> {};
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    namespace detail
+    {
+        template <typename T>
+        struct mpl_sequence_category_of
+        {
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((mpl::is_sequence<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_27;
+            typedef typename
+                mpl_iterator_category<
+                    typename mpl::begin<T>::type::category
+                >::type
+            type;
+        };
+    }
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct category_of_impl;
+        template<>
+        struct category_of_impl<mpl_sequence_tag>
+        {
+            template<typename T>
+            struct apply
+                : detail::mpl_sequence_category_of<T>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_view_impl;
+        template<>
+        struct is_view_impl<mpl_sequence_tag>
+        {
+            template<typename T>
+            struct apply : mpl::true_
+            {};
+        };
+    }
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct empty_impl;
+template< typename Sequence > struct empty;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct empty_impl
+{
+    template< typename Sequence > struct apply
+        : is_same<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+    };
+};
+ template<> struct empty_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct empty
+    : empty_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    struct mpl_sequence_tag;
+    namespace extension
+    {
+        template <typename Sequence>
+        struct empty_impl;
+        template <>
+        struct empty_impl<mpl_sequence_tag>
+        {
+            template <typename Sequence>
+            struct apply : mpl::empty<Sequence> {};
+        };
+    }
+}}
+namespace boost {
+namespace fusion
+{
+    struct fusion_sequence_tag;
+}
+namespace mpl
+{
+    template <typename Tag>
+    struct at_impl;
+    template <>
+    struct at_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename N>
+        struct apply : fusion::result_of::value_at<Sequence, N> {};
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct back_impl;
+template< typename Sequence > struct back;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct back_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename end<Sequence>::type end_;
+        typedef typename prior<end_>::type last_;
+        typedef typename deref<last_>::type type;
+    };
+};
+ template<> struct back_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct back
+    : back_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : back< T1 > { }; }; template< typename Tag > struct lambda< back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef back< na > result_; typedef back< na > type; }; namespace aux { template< typename T1 > struct template_arity< back< T1 > > : int_<1> { }; template<> struct template_arity< back< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct back_impl;
+    template <>
+    struct back_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply :
+            fusion::result_of::value_of<
+                typename fusion::result_of::prior<
+                    typename fusion::result_of::end<Sequence>::type
+                >::type> {};
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct clear_impl;
+template< typename Sequence > struct clear;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct clear_impl
+{
+    template< typename Sequence > struct apply;
+};
+ template<> struct clear_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct clear
+    : clear_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct clear< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : clear< T1 > { }; }; template< typename Tag > struct lambda< clear< na > , Tag , int_<-1> > { typedef false_ is_le; typedef clear< na > result_; typedef clear< na > type; }; namespace aux { template< typename T1 > struct template_arity< clear< T1 > > : int_<1> { }; template<> struct template_arity< clear< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    template <typename Dummy = void>
+    struct vector0;
+}}
+namespace boost { namespace fusion
+{
+    template <typename T0>
+    struct vector1;
+    template <typename T0 , typename T1>
+    struct vector2;
+    template <typename T0 , typename T1 , typename T2>
+    struct vector3;
+    template <typename T0 , typename T1 , typename T2 , typename T3>
+    struct vector4;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct vector5;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct vector6;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct vector7;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct vector8;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    struct vector9;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    struct vector10;
+}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct at_impl;
+        template <>
+        struct at_impl<vector_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef mpl::at<typename Sequence::types, N> element;
+                typedef typename detail::ref_result<element>::type type;
+                static type
+                call(Sequence& v)
+                {
+                    return v.at_impl(N());
+                }
+            };
+            template <typename Sequence, typename N>
+            struct apply <Sequence const, N>
+            {
+                typedef mpl::at<typename Sequence::types, N> element;
+                typedef typename detail::cref_result<element>::type type;
+                static type
+                call(Sequence const& v)
+                {
+                    return v.at_impl(N());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_at_impl;
+        template <>
+        struct value_at_impl<vector_tag>
+        {
+            template <typename Sequence, typename N>
+            struct apply
+            {
+                typedef typename mpl::at<typename Sequence::types, N>::type type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<vector_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::vector vector;
+                typedef typename Iterator::index index;
+                typedef typename mpl::at<
+                    typename vector::types, index>
+                element;
+                typedef typename
+                    mpl::eval_if<
+                        is_const<vector>
+                      , fusion::detail::cref_result<element>
+                      , fusion::detail::ref_result<element>
+                    >::type
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return i.vec.at_impl(index());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<vector_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::vector vector;
+                typedef typename Iterator::index index;
+                typedef typename mpl::at<
+                    typename vector::types, index>::type
+                type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    template <typename Vector, int N>
+    struct vector_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<vector_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::vector vector;
+                typedef typename Iterator::index index;
+                typedef vector_iterator<vector, index::value+1> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.vec);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    template <typename Vector, int N>
+    struct vector_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct prior_impl;
+        template <>
+        struct prior_impl<vector_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::vector vector;
+                typedef typename Iterator::index index;
+                typedef vector_iterator<vector, index::value-1> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.vec);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct equal_to_impl;
+        template <>
+        struct equal_to_impl<vector_iterator_tag>
+        {
+            template <typename I1, typename I2>
+            struct apply
+                : is_same<
+                    typename I1::identity
+                  , typename I2::identity
+                >
+            {
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct distance_impl;
+        template <>
+        struct distance_impl<vector_iterator_tag>
+        {
+            template <typename First, typename Last>
+            struct apply : mpl::minus<typename Last::index, typename First::index>
+            {
+                static typename mpl::minus<
+                    typename Last::index, typename First::index>::type
+                call(First const&, Last const&)
+                {
+                    typedef typename mpl::minus<
+                        typename Last::index, typename First::index>::type
+                    result;
+                    return result();
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    template <typename Vector, int N>
+    struct vector_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct advance_impl;
+        template <>
+        struct advance_impl<vector_iterator_tag>
+        {
+            template <typename Iterator, typename N>
+            struct apply
+            {
+                typedef typename Iterator::index index;
+                typedef typename Iterator::vector vector;
+                typedef vector_iterator<vector, index::value+N::value> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(i.vec);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_iterator_tag;
+    struct random_access_traversal_tag;
+    template <typename Vector, int N>
+    struct vector_iterator_identity;
+    template <typename Vector, int N>
+    struct vector_iterator : iterator_base<vector_iterator<Vector, N> >
+    {
+        typedef mpl::int_<N> index;
+        typedef Vector vector;
+        typedef vector_iterator_tag fusion_tag;
+        typedef random_access_traversal_tag category;
+        typedef vector_iterator_identity<
+            typename add_const<Vector>::type, N> identity;
+        vector_iterator(Vector& in_vec)
+            : vec(in_vec) {}
+        Vector& vec;
+    private:
+        vector_iterator& operator= (vector_iterator const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<vector_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef vector_iterator<Sequence, 0> type;
+                static type
+                call(Sequence& v)
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<vector_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::size size;
+                typedef vector_iterator<Sequence, size::value> type;
+                static type
+                call(Sequence& v)
+                {
+                    return type(v);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace mpl { namespace aux {
+struct v_iter_tag;
+struct vector_tag;
+}}}
+namespace boost { namespace mpl {
+template< typename Vector, long n_ >
+struct v_at_impl
+{
+    typedef long_< (Vector::lower_bound_::value + n_) > index_;
+    typedef __typeof__( Vector::item_(index_()) ) type;
+};
+template< typename Vector, long n_ >
+struct v_at
+    : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
+{
+};
+template<>
+struct at_impl< aux::vector_tag >
+{
+    template< typename Vector, typename N > struct apply
+        : v_at<
+              Vector
+            , N::value
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct front_impl;
+template< typename Sequence > struct front;
+}}
+namespace boost { namespace mpl {
+template<>
+struct front_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : v_at<Vector,0>
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct push_front_impl;
+template< typename Sequence, typename T > struct push_front;
+}}
+namespace boost { namespace mpl {
+template<
+      typename T
+    , typename Base
+    , int at_front = 0
+    >
+struct v_item
+    : Base
+{
+    typedef typename Base::upper_bound_ index_;
+    typedef typename next<index_>::type upper_bound_;
+    typedef typename next<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_item type;
+    static aux::type_wrapper<T> item_(index_);
+    using Base::item_;
+};
+template<
+      typename T
+    , typename Base
+    >
+struct v_item<T,Base,1>
+    : Base
+{
+    typedef typename prior<typename Base::lower_bound_>::type index_;
+    typedef index_ lower_bound_;
+    typedef typename next<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_item type;
+    static aux::type_wrapper<T> item_(index_);
+    using Base::item_;
+};
+template<
+      typename Base
+    , int at_front
+    >
+struct v_mask
+    : Base
+{
+    typedef typename prior<typename Base::upper_bound_>::type index_;
+    typedef index_ upper_bound_;
+    typedef typename prior<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_mask type;
+    static aux::type_wrapper<void_> item_(index_);
+    using Base::item_;
+};
+template<
+      typename Base
+    >
+struct v_mask<Base,1>
+    : Base
+{
+    typedef typename Base::lower_bound_ index_;
+    typedef typename next<index_>::type lower_bound_;
+    typedef typename prior<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_mask type;
+    static aux::type_wrapper<void_> item_(index_);
+    using Base::item_;
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct push_front_impl< aux::vector_tag >
+{
+    template< typename Vector, typename T > struct apply
+    {
+        typedef v_item<T,Vector,1> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct pop_front_impl;
+template< typename Sequence > struct pop_front;
+}}
+namespace boost { namespace mpl {
+template<>
+struct pop_front_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_mask<Vector,1> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct push_back_impl;
+template< typename Sequence, typename T > struct push_back;
+}}
+namespace boost { namespace mpl {
+template<>
+struct push_back_impl< aux::vector_tag >
+{
+    template< typename Vector, typename T > struct apply
+    {
+        typedef v_item<T,Vector,0> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct pop_back_impl;
+template< typename Sequence > struct pop_back;
+}}
+namespace boost { namespace mpl {
+template<>
+struct pop_back_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_mask<Vector,0> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct back_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : v_at<
+              Vector
+            , prior<typename Vector::size>::type::value
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Vector
+    , long n_
+    >
+struct v_iter
+{
+    typedef aux::v_iter_tag tag;
+    typedef random_access_iterator_tag category;
+    typedef typename v_at<Vector,n_>::type type;
+    typedef Vector vector_;
+    typedef mpl::long_<n_> pos;
+};
+template<
+      typename Vector
+    , long n_
+    >
+struct next< v_iter<Vector,n_> >
+{
+    typedef v_iter<Vector,(n_ + 1)> type;
+};
+template<
+      typename Vector
+    , long n_
+    >
+struct prior< v_iter<Vector,n_> >
+{
+    typedef v_iter<Vector,(n_ - 1)> type;
+};
+template<
+      typename Vector
+    , long n_
+    , typename Distance
+    >
+struct advance< v_iter<Vector,n_>,Distance>
+{
+    typedef v_iter<
+          Vector
+        , (n_ + Distance::value)
+        > type;
+};
+template<
+      typename Vector
+    , long n_
+    , long m_
+    >
+struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
+    : mpl::long_<(m_ - n_)>
+{
+};
+}}
+namespace boost { namespace mpl {
+template< typename Dummy = na > struct vector0;
+template<> struct vector0<na>
+{
+    typedef aux::vector_tag tag;
+    typedef vector0 type;
+    typedef long_<32768> lower_bound_;
+    typedef lower_bound_ upper_bound_;
+    typedef long_<0> size;
+    static aux::type_wrapper<void_> item_(...);
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct clear_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef vector0<> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct O1_size_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : Vector::size
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct size_impl< aux::vector_tag >
+    : O1_size_impl< aux::vector_tag >
+{
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct empty_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : is_same<
+              typename Vector::lower_bound_
+            , typename Vector::upper_bound_
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct begin_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_iter<Vector,0> type;
+    };
+};
+template<>
+struct end_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_iter<Vector,Vector::size::value> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0
+    >
+struct vector1
+    : v_item<
+          T0
+        , vector0< >
+        >
+{
+    typedef vector1 type;
+};
+template<
+      typename T0, typename T1
+    >
+struct vector2
+    : v_item<
+          T1
+        , vector1<T0>
+        >
+{
+    typedef vector2 type;
+};
+template<
+      typename T0, typename T1, typename T2
+    >
+struct vector3
+    : v_item<
+          T2
+        , vector2< T0,T1 >
+        >
+{
+    typedef vector3 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct vector4
+    : v_item<
+          T3
+        , vector3< T0,T1,T2 >
+        >
+{
+    typedef vector4 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct vector5
+    : v_item<
+          T4
+        , vector4< T0,T1,T2,T3 >
+        >
+{
+    typedef vector5 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct vector6
+    : v_item<
+          T5
+        , vector5< T0,T1,T2,T3,T4 >
+        >
+{
+    typedef vector6 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct vector7
+    : v_item<
+          T6
+        , vector6< T0,T1,T2,T3,T4,T5 >
+        >
+{
+    typedef vector7 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct vector8
+    : v_item<
+          T7
+        , vector7< T0,T1,T2,T3,T4,T5,T6 >
+        >
+{
+    typedef vector8 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct vector9
+    : v_item<
+          T8
+        , vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
+        >
+{
+    typedef vector9 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct vector10
+    : v_item<
+          T9
+        , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+        >
+{
+    typedef vector10 type;
+};
+}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    struct fusion_sequence_tag;
+    struct random_access_traversal_tag;
+    template <typename Dummy>
+    struct vector0 : sequence_base<vector0<Dummy> >
+    {
+        typedef mpl::vector0<> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<0> size;
+        vector0() {}
+        template<typename Sequence>
+        vector0(Sequence const& )
+        {}
+    };
+}}
+namespace boost { namespace fusion
+{
+    template <typename T0>
+    struct vector_data1
+    {
+        vector_data1()
+            : m0() {}
+        vector_data1(
+            typename detail::call_param<T0 >::type _0)
+            : m0(_0) {}
+        vector_data1(
+            vector_data1 const& other)
+            : m0(other.m0) {}
+        vector_data1&
+        operator=(vector_data1 const& vec)
+        {
+            this->m0 = vec.m0;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data1
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            return vector_data1(*i0);
+        }
+        T0 m0;
+    };
+    template <typename T0>
+    struct vector1
+      : vector_data1<T0>
+      , sequence_base<vector1<T0> >
+    {
+        typedef vector1<T0> this_type;
+        typedef vector_data1<T0> base_type;
+        typedef mpl::vector1<T0> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<1> size;
+        vector1() {}
+        explicit
+        vector1(
+            typename detail::call_param<T0 >::type _0)
+            : base_type(_0) {}
+        template <typename U0>
+        vector1(
+            vector1<U0> const& vec)
+            : base_type(vec.m0) {}
+        template <typename Sequence>
+        vector1(
+            Sequence const& seq
+          , typename boost::disable_if<is_convertible<Sequence, T0> >::type* = 0
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0>
+        vector1&
+        operator=(vector1<U0> const& vec)
+        {
+            this->m0 = vec.m0;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            this->m0 = *i0;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1>
+    struct vector_data2
+    {
+        vector_data2()
+            : m0() , m1() {}
+        vector_data2(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1)
+            : m0(_0) , m1(_1) {}
+        vector_data2(
+            vector_data2 const& other)
+            : m0(other.m0) , m1(other.m1) {}
+        vector_data2&
+        operator=(vector_data2 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data2
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
+            return vector_data2(*i0 , *i1);
+        }
+        T0 m0; T1 m1;
+    };
+    template <typename T0 , typename T1>
+    struct vector2
+      : vector_data2<T0 , T1>
+      , sequence_base<vector2<T0 , T1> >
+    {
+        typedef vector2<T0 , T1> this_type;
+        typedef vector_data2<T0 , T1> base_type;
+        typedef mpl::vector2<T0 , T1> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<2> size;
+        vector2() {}
+        vector2(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1)
+            : base_type(_0 , _1) {}
+        template <typename U0 , typename U1>
+        vector2(
+            vector2<U0 , U1> const& vec)
+            : base_type(vec.m0 , vec.m1) {}
+        template <typename Sequence>
+        vector2(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1>
+        vector2&
+        operator=(vector2<U0 , U1> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0);
+            this->m0 = *i0; this->m1 = *i1;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2>
+    struct vector_data3
+    {
+        vector_data3()
+            : m0() , m1() , m2() {}
+        vector_data3(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2)
+            : m0(_0) , m1(_1) , m2(_2) {}
+        vector_data3(
+            vector_data3 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) {}
+        vector_data3&
+        operator=(vector_data3 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data3
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1);
+            return vector_data3(*i0 , *i1 , *i2);
+        }
+        T0 m0; T1 m1; T2 m2;
+    };
+    template <typename T0 , typename T1 , typename T2>
+    struct vector3
+      : vector_data3<T0 , T1 , T2>
+      , sequence_base<vector3<T0 , T1 , T2> >
+    {
+        typedef vector3<T0 , T1 , T2> this_type;
+        typedef vector_data3<T0 , T1 , T2> base_type;
+        typedef mpl::vector3<T0 , T1 , T2> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<3> size;
+        vector3() {}
+        vector3(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2)
+            : base_type(_0 , _1 , _2) {}
+        template <typename U0 , typename U1 , typename U2>
+        vector3(
+            vector3<U0 , U1 , U2> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2) {}
+        template <typename Sequence>
+        vector3(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2>
+        vector3&
+        operator=(vector3<U0 , U1 , U2> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3>
+    struct vector_data4
+    {
+        vector_data4()
+            : m0() , m1() , m2() , m3() {}
+        vector_data4(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) {}
+        vector_data4(
+            vector_data4 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) {}
+        vector_data4&
+        operator=(vector_data4 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data4
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2);
+            return vector_data4(*i0 , *i1 , *i2 , *i3);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3>
+    struct vector4
+      : vector_data4<T0 , T1 , T2 , T3>
+      , sequence_base<vector4<T0 , T1 , T2 , T3> >
+    {
+        typedef vector4<T0 , T1 , T2 , T3> this_type;
+        typedef vector_data4<T0 , T1 , T2 , T3> base_type;
+        typedef mpl::vector4<T0 , T1 , T2 , T3> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<4> size;
+        vector4() {}
+        vector4(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3)
+            : base_type(_0 , _1 , _2 , _3) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3>
+        vector4(
+            vector4<U0 , U1 , U2 , U3> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3) {}
+        template <typename Sequence>
+        vector4(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3>
+        vector4&
+        operator=(vector4<U0 , U1 , U2 , U3> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct vector_data5
+    {
+        vector_data5()
+            : m0() , m1() , m2() , m3() , m4() {}
+        vector_data5(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) {}
+        vector_data5(
+            vector_data5 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) {}
+        vector_data5&
+        operator=(vector_data5 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data5
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3);
+            return vector_data5(*i0 , *i1 , *i2 , *i3 , *i4);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct vector5
+      : vector_data5<T0 , T1 , T2 , T3 , T4>
+      , sequence_base<vector5<T0 , T1 , T2 , T3 , T4> >
+    {
+        typedef vector5<T0 , T1 , T2 , T3 , T4> this_type;
+        typedef vector_data5<T0 , T1 , T2 , T3 , T4> base_type;
+        typedef mpl::vector5<T0 , T1 , T2 , T3 , T4> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<5> size;
+        vector5() {}
+        vector5(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4)
+            : base_type(_0 , _1 , _2 , _3 , _4) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
+        vector5(
+            vector5<U0 , U1 , U2 , U3 , U4> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4) {}
+        template <typename Sequence>
+        vector5(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
+        vector5&
+        operator=(vector5<U0 , U1 , U2 , U3 , U4> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct vector_data6
+    {
+        vector_data6()
+            : m0() , m1() , m2() , m3() , m4() , m5() {}
+        vector_data6(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) , m5(_5) {}
+        vector_data6(
+            vector_data6 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) {}
+        vector_data6&
+        operator=(vector_data6 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data6
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4);
+            return vector_data6(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct vector6
+      : vector_data6<T0 , T1 , T2 , T3 , T4 , T5>
+      , sequence_base<vector6<T0 , T1 , T2 , T3 , T4 , T5> >
+    {
+        typedef vector6<T0 , T1 , T2 , T3 , T4 , T5> this_type;
+        typedef vector_data6<T0 , T1 , T2 , T3 , T4 , T5> base_type;
+        typedef mpl::vector6<T0 , T1 , T2 , T3 , T4 , T5> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<6> size;
+        vector6() {}
+        vector6(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5)
+            : base_type(_0 , _1 , _2 , _3 , _4 , _5) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
+        vector6(
+            vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5) {}
+        template <typename Sequence>
+        vector6(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
+        vector6&
+        operator=(vector6<U0 , U1 , U2 , U3 , U4 , U5> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct vector_data7
+    {
+        vector_data7()
+            : m0() , m1() , m2() , m3() , m4() , m5() , m6() {}
+        vector_data7(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) , m5(_5) , m6(_6) {}
+        vector_data7(
+            vector_data7 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) {}
+        vector_data7&
+        operator=(vector_data7 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data7
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5);
+            return vector_data7(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct vector7
+      : vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6>
+      , sequence_base<vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> >
+    {
+        typedef vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> this_type;
+        typedef vector_data7<T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
+        typedef mpl::vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<7> size;
+        vector7() {}
+        vector7(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6)
+            : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
+        vector7(
+            vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6) {}
+        template <typename Sequence>
+        vector7(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
+        vector7&
+        operator=(vector7<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct vector_data8
+    {
+        vector_data8()
+            : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() {}
+        vector_data8(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) , m5(_5) , m6(_6) , m7(_7) {}
+        vector_data8(
+            vector_data8 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) {}
+        vector_data8&
+        operator=(vector_data8 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data8
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6);
+            return vector_data8(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct vector8
+      : vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+      , sequence_base<vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> >
+    {
+        typedef vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> this_type;
+        typedef vector_data8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
+        typedef mpl::vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<8> size;
+        vector8() {}
+        vector8(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7)
+            : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
+        vector8(
+            vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7) {}
+        template <typename Sequence>
+        vector8(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
+        vector8&
+        operator=(vector8<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    struct vector_data9
+    {
+        vector_data9()
+            : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() {}
+        vector_data9(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) , m5(_5) , m6(_6) , m7(_7) , m8(_8) {}
+        vector_data9(
+            vector_data9 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) , m8(other.m8) {}
+        vector_data9&
+        operator=(vector_data9 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data9
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7);
+            return vector_data9(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    struct vector9
+      : vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+      , sequence_base<vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> >
+    {
+        typedef vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> this_type;
+        typedef vector_data9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
+        typedef mpl::vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<9> size;
+        vector9() {}
+        vector9(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8)
+            : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
+        vector9(
+            vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8) {}
+        template <typename Sequence>
+        vector9(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
+        vector9&
+        operator=(vector9<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7; this->m8 = *i8;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    struct vector_data10
+    {
+        vector_data10()
+            : m0() , m1() , m2() , m3() , m4() , m5() , m6() , m7() , m8() , m9() {}
+        vector_data10(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8 , typename detail::call_param<T9 >::type _9)
+            : m0(_0) , m1(_1) , m2(_2) , m3(_3) , m4(_4) , m5(_5) , m6(_6) , m7(_7) , m8(_8) , m9(_9) {}
+        vector_data10(
+            vector_data10 const& other)
+            : m0(other.m0) , m1(other.m1) , m2(other.m2) , m3(other.m3) , m4(other.m4) , m5(other.m5) , m6(other.m6) , m7(other.m7) , m8(other.m8) , m9(other.m9) {}
+        vector_data10&
+        operator=(vector_data10 const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8; this->m9 = vec.m9;
+            return *this;
+        }
+        template <typename Sequence>
+        static vector_data10
+        init_from_sequence(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7); typedef typename result_of::next< I8>::type I9; I9 i9 = fusion::next(i8);
+            return vector_data10(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
+        }
+        T0 m0; T1 m1; T2 m2; T3 m3; T4 m4; T5 m5; T6 m6; T7 m7; T8 m8; T9 m9;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    struct vector10
+      : vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+      , sequence_base<vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> >
+    {
+        typedef vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> this_type;
+        typedef vector_data10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
+        typedef mpl::vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> types;
+        typedef vector_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::false_ is_view;
+        typedef random_access_traversal_tag category;
+        typedef mpl::int_<10> size;
+        vector10() {}
+        vector10(
+            typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8 , typename detail::call_param<T9 >::type _9)
+            : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+        vector10(
+            vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
+            : base_type(vec.m0 , vec.m1 , vec.m2 , vec.m3 , vec.m4 , vec.m5 , vec.m6 , vec.m7 , vec.m8 , vec.m9) {}
+        template <typename Sequence>
+        vector10(
+            Sequence const& seq
+            )
+            : base_type(base_type::init_from_sequence(seq)) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+        vector10&
+        operator=(vector10<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& vec)
+        {
+            this->m0 = vec.m0; this->m1 = vec.m1; this->m2 = vec.m2; this->m3 = vec.m3; this->m4 = vec.m4; this->m5 = vec.m5; this->m6 = vec.m6; this->m7 = vec.m7; this->m8 = vec.m8; this->m9 = vec.m9;
+            return *this;
+        }
+        template <typename Sequence>
+        typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
+        operator=(Sequence const& seq)
+        {
+            typedef typename result_of::begin<Sequence const>::type I0;
+            I0 i0 = fusion::begin(seq);
+            typedef typename result_of::next< I0>::type I1; I1 i1 = fusion::next(i0); typedef typename result_of::next< I1>::type I2; I2 i2 = fusion::next(i1); typedef typename result_of::next< I2>::type I3; I3 i3 = fusion::next(i2); typedef typename result_of::next< I3>::type I4; I4 i4 = fusion::next(i3); typedef typename result_of::next< I4>::type I5; I5 i5 = fusion::next(i4); typedef typename result_of::next< I5>::type I6; I6 i6 = fusion::next(i5); typedef typename result_of::next< I6>::type I7; I7 i7 = fusion::next(i6); typedef typename result_of::next< I7>::type I8; I8 i8 = fusion::next(i7); typedef typename result_of::next< I8>::type I9; I9 i9 = fusion::next(i8);
+            this->m0 = *i0; this->m1 = *i1; this->m2 = *i2; this->m3 = *i3; this->m4 = *i4; this->m5 = *i5; this->m6 = *i6; this->m7 = *i7; this->m8 = *i8; this->m9 = *i9;
+            return *this;
+        }
+        typename add_reference<T0>::type at_impl(mpl::int_<0>) { return this->m0; } typename add_reference<typename add_const<T0>::type>::type at_impl(mpl::int_<0>) const { return this->m0; } typename add_reference<T1>::type at_impl(mpl::int_<1>) { return this->m1; } typename add_reference<typename add_const<T1>::type>::type at_impl(mpl::int_<1>) const { return this->m1; } typename add_reference<T2>::type at_impl(mpl::int_<2>) { return this->m2; } typename add_reference<typename add_const<T2>::type>::type at_impl(mpl::int_<2>) const { return this->m2; } typename add_reference<T3>::type at_impl(mpl::int_<3>) { return this->m3; } typename add_reference<typename add_const<T3>::type>::type at_impl(mpl::int_<3>) const { return this->m3; } typename add_reference<T4>::type at_impl(mpl::int_<4>) { return this->m4; } typename add_reference<typename add_const<T4>::type>::type at_impl(mpl::int_<4>) const { return this->m4; } typename add_reference<T5>::type at_impl(mpl::int_<5>) { return this->m5; } typename add_reference<typename add_const<T5>::type>::type at_impl(mpl::int_<5>) const { return this->m5; } typename add_reference<T6>::type at_impl(mpl::int_<6>) { return this->m6; } typename add_reference<typename add_const<T6>::type>::type at_impl(mpl::int_<6>) const { return this->m6; } typename add_reference<T7>::type at_impl(mpl::int_<7>) { return this->m7; } typename add_reference<typename add_const<T7>::type>::type at_impl(mpl::int_<7>) const { return this->m7; } typename add_reference<T8>::type at_impl(mpl::int_<8>) { return this->m8; } typename add_reference<typename add_const<T8>::type>::type at_impl(mpl::int_<8>) const { return this->m8; } typename add_reference<T9>::type at_impl(mpl::int_<9>) { return this->m9; } typename add_reference<typename add_const<T9>::type>::type at_impl(mpl::int_<9>) const { return this->m9; }
+        template<typename I>
+        typename add_reference<typename mpl::at<types, I>::type>::type
+        at_impl(I)
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
+        at_impl(I) const
+        {
+            return this->at_impl(mpl::int_<I::value>());
+        }
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    template <
+        typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
+    >
+    struct vector;
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct map_tag;
+    struct map_iterator_tag;
+    template <
+        typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
+    >
+    struct map;
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct set_tag;
+    struct set_iterator_tag;
+    template <
+        typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
+    >
+    struct set;
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    template<
+        typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_>
+    struct deque;
+}}
+namespace boost { namespace fusion
+{
+    struct cons_tag;
+    struct map_tag;
+    struct set_tag;
+    struct vector_tag;
+    struct deque_tag;
+    namespace detail
+    {
+        template <typename Tag>
+        struct clear;
+        template <>
+        struct clear<cons_tag> : mpl::identity<list<> > {};
+        template <>
+        struct clear<map_tag> : mpl::identity<map<> > {};
+        template <>
+        struct clear<set_tag> : mpl::identity<set<> > {};
+        template <>
+        struct clear<vector_tag> : mpl::identity<vector<> > {};
+        template <>
+        struct clear<deque_tag> : mpl::identity<deque<> > {};
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct clear_impl;
+    template <>
+    struct clear_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply
+        {
+            typedef typename
+                fusion::detail::clear<typename fusion::detail::tag_of<Sequence>::type>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct empty_impl;
+    template <>
+    struct empty_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply : fusion::result_of::empty<Sequence> {};
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct erase_impl;
+template< typename Sequence, typename First, typename Last > struct erase;
+}}
+namespace boost { namespace mpl {
+struct has_push_front_arg {};
+template< typename Tag >
+struct push_front_impl
+{
+    template< typename Sequence, typename T > struct apply
+    {
+        struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct
+ REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST45
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } }
+ mpl_assert_arg45
+        ; enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg45::assert_arg() ) ) }
+             ;
+    };
+};
+template< typename Tag >
+struct has_push_front_impl
+{
+    template< typename Seq > struct apply
+        : aux::has_type< push_front< Seq, has_push_front_arg > >
+    {
+    };
+};
+ template<> struct push_front_impl<non_sequence_tag> {};
+ template<> struct has_push_front_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename T = na
+    >
+struct push_front
+    : push_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,T >
+{
+};
+template<
+      typename Sequence = na
+    >
+struct has_push_front
+    : has_push_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
+template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl;
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef fwd_state0 bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter0 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef fwd_state1 bkwd_state1;
+    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter1 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef fwd_state2 bkwd_state2;
+    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
+    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter2 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef fwd_state3 bkwd_state3;
+    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
+    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
+    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter3 iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
+    typedef typename mpl::next<iter3>::type iter4;
+    typedef fwd_state4 bkwd_state4;
+    typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
+    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
+    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
+    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter4 iterator;
+};
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename apply2< ForwardOp, fwd_state0, typename deref<iter0>::type >::type fwd_state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp, fwd_state1, typename deref<iter1>::type >::type fwd_state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp, fwd_state2, typename deref<iter2>::type >::type fwd_state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef typename apply2< ForwardOp, fwd_state3, typename deref<iter3>::type >::type fwd_state4;
+    typedef typename mpl::next<iter3>::type iter4;
+    typedef reverse_fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , iter4
+        , Last
+        , fwd_state4
+        , BackwardOp
+        , ForwardOp
+        > nested_chunk;
+    typedef typename nested_chunk::state bkwd_state4;
+    typedef typename apply2< BackwardOp, bkwd_state4, typename deref<iter3>::type >::type bkwd_state3;
+    typedef typename apply2< BackwardOp, bkwd_state3, typename deref<iter2>::type >::type bkwd_state2;
+    typedef typename apply2< BackwardOp, bkwd_state2, typename deref<iter1>::type >::type bkwd_state1;
+    typedef typename apply2< BackwardOp, bkwd_state1, typename deref<iter0>::type >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef typename nested_chunk::iterator iterator;
+};
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef reverse_fold_impl<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2<ForwardOp,State, typename deref<First>::type>::type
+        , BackwardOp
+        , ForwardOp
+        > nested_step;
+    typedef typename apply2<
+          BackwardOp
+        , typename nested_step::state
+        , typename deref<First>::type
+        >::type state;
+    typedef typename nested_step::iterator iterator;
+};
+template<
+      typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename State = na
+    , typename BackwardOp = na
+    , typename ForwardOp = arg<1>
+    >
+struct reverse_fold
+{
+    typedef typename aux::reverse_fold_impl<
+          ::boost::mpl::O1_size<Sequence>::value
+        , typename begin<Sequence>::type
+        , typename end<Sequence>::type
+        , State
+        , BackwardOp
+        , ForwardOp
+        >::state type;
+};
+template<> struct reverse_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_fold< na , na , na > result_; typedef reverse_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_fold< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct erase_impl
+{
+    template<
+          typename Sequence
+        , typename First
+        , typename Last
+        >
+    struct apply
+    {
+        typedef typename if_na< Last,typename next<First>::type >::type last_;
+        typedef iterator_range<
+              typename begin<Sequence>::type
+            , First
+            > first_half_;
+        typedef iterator_range<
+              last_
+            , typename end<Sequence>::type
+            > second_half_;
+        typedef typename reverse_fold<
+              second_half_
+            , typename clear<Sequence>::type
+            , push_front<_,_>
+            >::type half_sequence_;
+        typedef typename reverse_fold<
+              first_half_
+            , half_sequence_
+            , push_front<_,_>
+            >::type type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename First = na
+    , typename Last = na
+    >
+struct erase
+    : erase_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,First,Last >
+{
+};
+template<> struct erase< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : erase< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< erase< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef erase< na , na , na > result_; typedef erase< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< erase< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< erase< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename First>
+        struct compute_erase_last
+        {
+            typedef typename result_of::end<Sequence>::type seq_last_type;
+            typedef typename convert_iterator<First>::type first_type;
+            typedef typename
+                mpl::if_<
+                    result_of::equal_to<first_type, seq_last_type>
+                  , first_type
+                  , typename result_of::next<first_type>::type
+                >::type
+            type;
+            static type
+            call(First const& first, mpl::false_)
+            {
+                return fusion::next(convert_iterator<First>::call(first));
+            }
+            static type
+            call(First const& first, mpl::true_)
+            {
+                return convert_iterator<First>::call(first);
+            }
+            static type
+            call(First const& first)
+            {
+                return call(first, result_of::equal_to<first_type, seq_last_type>());
+            }
+        };
+        template <
+            typename Sequence
+          , typename First
+          , typename Last = typename compute_erase_last<Sequence, First>::type>
+        struct erase
+        {
+            typedef typename result_of::begin<Sequence>::type seq_first_type;
+            typedef typename result_of::end<Sequence>::type seq_last_type;
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!result_of::equal_to<seq_first_type, seq_last_type>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_64;
+            typedef typename convert_iterator<First>::type first_type;
+            typedef typename convert_iterator<Last>::type last_type;
+            typedef iterator_range<seq_first_type, first_type> left_type;
+            typedef iterator_range<last_type, seq_last_type> right_type;
+            typedef joint_view<left_type, right_type> type;
+        };
+    }
+    template <typename Sequence, typename First>
+    typename result_of::erase<Sequence const, First>::type
+    erase(Sequence const& seq, First const& first)
+    {
+        typedef result_of::erase<Sequence const, First> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::type result_type;
+        left_type left(
+            fusion::begin(seq)
+          , convert_iterator<First>::call(first));
+        right_type right(
+            fusion::result_of::compute_erase_last<Sequence const, First>::call(first)
+          , fusion::end(seq));
+        return result_type(left, right);
+    }
+    template <typename Sequence, typename First, typename Last>
+    typename result_of::erase<Sequence const, First, Last>::type
+    erase(Sequence const& seq, First const& first, Last const& last)
+    {
+        typedef result_of::erase<Sequence const, First, Last> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::type result_type;
+        left_type left(fusion::begin(seq), first);
+        right_type right(last, fusion::end(seq));
+        return result_type(left, right);
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template <typename Tag>
+        struct convert_impl;
+    }
+    namespace result_of
+    {
+        template <typename Tag, typename Sequence>
+        struct convert
+        {
+            typedef typename extension::convert_impl<Tag> gen;
+            typedef typename
+                gen::template apply<Sequence>::type
+            type;
+        };
+    }
+    template <typename Tag, typename Sequence>
+    inline typename result_of::convert<Tag, Sequence>::type
+    convert(Sequence& seq)
+    {
+        typedef typename result_of::convert<Tag, Sequence>::gen gen;
+        return gen::call(seq);
+    }
+    template <typename Tag, typename Sequence>
+    inline typename result_of::convert<Tag, Sequence const>::type
+    convert(Sequence const& seq)
+    {
+        typedef typename result_of::convert<Tag, Sequence const>::gen gen;
+        return gen::call(seq);
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct erase_impl;
+    template <>
+    struct erase_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename First, typename Last>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::erase<Sequence, First, Last>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct erase_key_impl;
+template< typename Sequence, typename Key > struct erase_key;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct erase_key_impl
+{
+    template< typename Sequence, typename Key > struct apply;
+};
+ template<> struct erase_key_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename Key = na
+    >
+struct erase_key
+    : erase_key_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Key >
+{
+};
+template<> struct erase_key< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : erase_key< T1 , T2 > { }; }; template< typename Tag > struct lambda< erase_key< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef erase_key< na , na > result_; typedef erase_key< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< erase_key< T1 , T2 > > : int_<2> { }; template<> struct template_arity< erase_key< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct erase_key
+          : erase<Sequence, typename find<Sequence, Key>::type>
+        {};
+    }
+    template <typename Key, typename Sequence>
+    inline typename result_of::erase_key<Sequence const, Key>::type
+    erase_key(Sequence const& seq)
+    {
+        return erase(seq, find<Key>(seq));
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct erase_key_impl;
+    template <>
+    struct erase_key_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename Key>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::erase_key<Sequence, Key>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct front_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename begin<Sequence>::type iter_;
+        typedef typename deref<iter_>::type type;
+    };
+};
+ template<> struct front_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct front
+    : front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : front< T1 > { }; }; template< typename Tag > struct lambda< front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef front< na > result_; typedef front< na > type; }; namespace aux { template< typename T1 > struct template_arity< front< T1 > > : int_<1> { }; template<> struct template_arity< front< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct front_impl;
+    template <>
+    struct front_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply :
+            fusion::result_of::value_of<typename fusion::result_of::begin<Sequence>::type> {};
+    };
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct has_key_impl;
+    template <>
+    struct has_key_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename Key>
+        struct apply : fusion::result_of::has_key<Sequence, Key> {};
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct insert_impl;
+template< typename Sequence, typename Pos_or_T, typename T > struct insert;
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct insert_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename T
+        >
+    struct apply
+    {
+        typedef iterator_range<
+              typename begin<Sequence>::type
+            , Pos
+            > first_half_;
+        typedef iterator_range<
+              Pos
+            , typename end<Sequence>::type
+            > second_half_;
+        typedef typename reverse_fold<
+              second_half_
+            , typename clear<Sequence>::type
+            , push_front<_,_>
+            >::type half_sequence_;
+        typedef typename reverse_fold<
+              first_half_
+            , typename push_front<half_sequence_,T>::type
+            , push_front<_,_>
+            >::type type;
+    };
+};
+ template<> struct insert_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename Pos_or_T = na
+    , typename T = na
+    >
+struct insert
+    : insert_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Pos_or_T,T >
+{
+};
+template<> struct insert< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : insert< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< insert< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef insert< na , na , na > result_; typedef insert< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< insert< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< insert< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Position, typename T>
+        struct insert
+        {
+            typedef typename detail::as_fusion_element<T>::type element_type;
+            typedef typename convert_iterator<Position>::type pos_type;
+            typedef typename result_of::begin<Sequence>::type first_type;
+            typedef typename result_of::end<Sequence>::type last_type;
+            typedef iterator_range<first_type, pos_type> left_type;
+            typedef iterator_range<pos_type, last_type> right_type;
+            typedef fusion::single_view<element_type> single_view;
+            typedef joint_view<left_type, single_view const> left_insert_type;
+            typedef joint_view<left_insert_type, right_type> type;
+        };
+    }
+    template <typename Sequence, typename Position, typename T>
+    inline typename result_of::insert<
+        Sequence const, Position, T>::type
+    insert(Sequence const& seq, Position const& pos, T const& x)
+    {
+        typedef result_of::insert<
+            Sequence const, Position, T>
+        result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::single_view single_view;
+        typedef typename result_of::left_insert_type left_insert_type;
+        typedef typename result_of::type result;
+        left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos));
+        right_type right(convert_iterator<Position>::call(pos), fusion::end(seq));
+        single_view insert(x);
+        left_insert_type left_insert(left, insert);
+        return result(left_insert, right);
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct insert_impl;
+    template <>
+    struct insert_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename Pos, typename T>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::insert<Sequence, Pos, T>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct insert_range_impl;
+template< typename Sequence, typename Pos, typename Range > struct insert_range;
+}}
+namespace boost { namespace mpl {
+struct has_push_back_arg {};
+template< typename Tag >
+struct push_back_impl
+{
+    template< typename Sequence, typename T > struct apply
+    {
+        struct REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct
+ REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST44
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_BACK_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } }
+ mpl_assert_arg44
+        ; enum { mpl_assertion_in_line_44 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_back_arg >::value ))>( mpl_assert_arg44::assert_arg() ) ) }
+             ;
+    };
+};
+template< typename Tag >
+struct has_push_back_impl
+{
+    template< typename Seq > struct apply
+        : aux::has_type< push_back< Seq, has_push_back_arg > >
+    {
+    };
+};
+ template<> struct push_back_impl<non_sequence_tag> {};
+ template<> struct has_push_back_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename T = na
+    >
+struct push_back
+    : push_back_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,T >
+{
+};
+template<
+      typename Sequence = na
+    >
+struct has_push_back
+    : has_push_back_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct push_back< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_back< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_back< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_back< na , na > result_; typedef push_back< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_back< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_back< na , na > > : int_<-1> { }; }
+template<> struct has_push_back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_back< T1 > { }; }; template< typename Tag > struct lambda< has_push_back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_back< na > result_; typedef has_push_back< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_back< T1 > > : int_<1> { }; template<> struct template_arity< has_push_back< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence
+    , typename Operation
+    >
+struct inserter
+{
+    typedef Sequence state;
+    typedef Operation operation;
+};
+}}
+namespace boost {
+namespace mpl {
+template<
+      typename Sequence
+    >
+struct back_inserter
+    : inserter< Sequence,push_back<> >
+{
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence
+    >
+struct front_inserter
+    : inserter< Sequence,push_front<> >
+{
+};
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template<
+      typename Sequence
+    , typename Inserter
+    >
+struct copy_impl
+    : fold<
+          Sequence
+        , typename Inserter::state
+        , typename Inserter::operation
+        >
+{
+};
+template<
+      typename Sequence
+    , typename Inserter
+    >
+struct reverse_copy_impl
+    : reverse_fold<
+          Sequence
+        , typename Inserter::state
+        , typename Inserter::operation
+        >
+{
+};
+}
+ template< typename P1 = na , typename P2 = na > struct copy : aux::copy_impl< P1 , P2> { }; template< typename P1 > struct copy< P1,na > : if_< has_push_back< typename clear<P1>::type> , aux::copy_impl< P1 , back_inserter< typename clear<P1>::type > > , aux::reverse_copy_impl< P1 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na > struct reverse_copy : aux::reverse_copy_impl< P1 , P2> { }; template< typename P1 > struct reverse_copy< P1,na > : if_< has_push_back<P1> , aux::reverse_copy_impl< P1 , back_inserter< typename clear<P1>::type > > , aux::copy_impl< P1 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct copy< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : copy< T1 , T2 > { }; }; template< typename Tag > struct lambda< copy< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef copy< na , na > result_; typedef copy< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< copy< T1 , T2 > > : int_<2> { }; template<> struct template_arity< copy< na , na > > : int_<-1> { }; } template<> struct reverse_copy< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : reverse_copy< T1 , T2 > { }; }; template< typename Tag > struct lambda< reverse_copy< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_copy< na , na > result_; typedef reverse_copy< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< reverse_copy< T1 , T2 > > : int_<2> { }; template<> struct template_arity< reverse_copy< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+{
+    typedef Iterator1 base;
+    typedef forward_iterator_tag category;
+};
+template<
+      typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter<LastIterator1,LastIterator1,Iterator2>
+{
+    typedef Iterator2 base;
+    typedef forward_iterator_tag category;
+};
+template< typename I1, typename L1, typename I2 >
+struct deref< joint_iter<I1,L1,I2> >
+{
+    typedef typename joint_iter<I1,L1,I2>::base base_;
+    typedef typename deref<base_>::type type;
+};
+template< typename I1, typename L1, typename I2 >
+struct next< joint_iter<I1,L1,I2> >
+{
+    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
+};
+template< typename L1, typename I2 >
+struct next< joint_iter<L1,L1,I2> >
+{
+    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
+};
+template< typename T1 , typename T2 , typename T3 , typename Tag > struct lambda< joint_iter< T1 , T2 , T3 > , Tag , int_<3> > { typedef false_ is_le; typedef joint_iter< T1 , T2 , T3 > result_; typedef result_ type; };
+}}
+namespace boost { namespace mpl {
+namespace aux {
+struct joint_view_tag;
+}
+template<>
+struct size_impl< aux::joint_view_tag >
+{
+    template < typename JointView > struct apply
+      : plus<
+            size<typename JointView::sequence1_>
+          , size<typename JointView::sequence2_>
+          >
+    {};
+};
+template<
+      typename Sequence1_ = na
+    , typename Sequence2_ = na
+    >
+struct joint_view
+{
+    typedef typename mpl::begin<Sequence1_>::type first1_;
+    typedef typename mpl::end<Sequence1_>::type last1_;
+    typedef typename mpl::begin<Sequence2_>::type first2_;
+    typedef typename mpl::end<Sequence2_>::type last2_;
+    typedef Sequence1_ sequence1_;
+    typedef Sequence2_ sequence2_;
+    typedef joint_view type;
+    typedef aux::joint_view_tag tag;
+    typedef joint_iter<first1_,last1_,first2_> begin;
+    typedef joint_iter<last1_,last1_,last2_> end;
+};
+template<> struct joint_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : joint_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< joint_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef joint_view< na , na > result_; typedef joint_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< joint_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< joint_view< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl { namespace aux {
+template<
+      typename Sequence
+    , typename Iterator
+    >
+struct iter_push_front
+{
+    typedef typename push_front<
+          Sequence
+        , typename deref<Iterator>::type
+        >::type type;
+};
+}}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct insert_range_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename Range
+        >
+    struct apply
+        : reverse_copy<
+              joint_view<
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view<
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , front_inserter< typename clear<Sequence>::type >
+            >
+    {
+    };
+};
+ template<> struct insert_range_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename Pos = na
+    , typename Range = na
+    >
+struct insert_range
+    : insert_range_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Pos,Range >
+{
+};
+template<> struct insert_range< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : insert_range< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< insert_range< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef insert_range< na , na , na > result_; typedef insert_range< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< insert_range< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< insert_range< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Position, typename Range>
+        struct insert_range
+        {
+            typedef typename convert_iterator<Position>::type pos_type;
+            typedef typename result_of::begin<Sequence>::type first_type;
+            typedef typename result_of::end<Sequence>::type last_type;
+            typedef iterator_range<first_type, pos_type> left_type;
+            typedef iterator_range<pos_type, last_type> right_type;
+            typedef joint_view<left_type, Range> left_insert_type;
+            typedef joint_view<left_insert_type, right_type> type;
+        };
+    }
+    template <typename Sequence, typename Position, typename Range>
+    inline typename result_of::insert_range<Sequence const, Position, Range const>::type
+    insert_range(Sequence const& seq, Position const& pos, Range const& range)
+    {
+        typedef result_of::insert_range<Sequence const, Position, Range const> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::left_insert_type left_insert_type;
+        typedef typename result_of::type result;
+        left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos));
+        right_type right(convert_iterator<Position>::call(pos), fusion::end(seq));
+        left_insert_type left_insert(left, range);
+        return result(left_insert, right);
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct insert_range_impl;
+    template <>
+    struct insert_range_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename Pos, typename Range>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::insert_range<Sequence, Pos, Range>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct pop_back_impl
+{
+    template< typename Sequence > struct apply;
+};
+ template<> struct pop_back_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct pop_back
+    : pop_back_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct pop_back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pop_back< T1 > { }; }; template< typename Tag > struct lambda< pop_back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef pop_back< na > result_; typedef pop_back< na > type; }; namespace aux { template< typename T1 > struct template_arity< pop_back< T1 > > : int_<1> { }; template<> struct template_arity< pop_back< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    template <typename Derived_, typename Iterator_,
+        typename Category = typename Iterator_::category>
+    struct iterator_adapter
+        : iterator_facade<Derived_, Category>
+    {
+        typedef typename
+            remove_const<Iterator_>::type
+        iterator_base_type;
+        iterator_base_type iterator_base;
+        iterator_adapter(iterator_base_type const& iterator_base)
+            : iterator_base(iterator_base) {}
+        template <typename I1, typename I2>
+        struct equal_to
+            : result_of::equal_to<
+                typename I1::iterator_base_type
+              , typename I2::iterator_base_type
+            >
+        {};
+        template <typename Iterator, typename N>
+        struct advance
+        {
+            typedef typename Derived_::template make<
+                typename result_of::advance<
+                    typename Iterator::iterator_base_type, N
+                >::type>::type
+            type;
+            static type
+            call(Iterator const& it)
+            {
+                return type(fusion::advance<N>(it.iterator_base));
+            }
+        };
+        template <typename First, typename Last>
+        struct distance
+            : result_of::distance<
+                typename First::iterator_base_type
+              , typename Last::iterator_base_type
+            >
+        {};
+        template <typename Iterator>
+        struct value_of
+            : result_of::value_of<
+                typename Iterator::iterator_base_type
+            >
+        {};
+        template <typename Iterator>
+        struct deref
+        {
+            typedef typename
+                result_of::deref<
+                    typename Iterator::iterator_base_type
+                >::type
+            type;
+            static type
+            call(Iterator const& it)
+            {
+                return fusion::deref(it.iterator_base);
+            }
+        };
+        template <typename Iterator>
+        struct next
+        {
+            typedef typename Derived_::template make<
+                typename result_of::next<
+                    typename Iterator::iterator_base_type
+                >::type>::type
+            type;
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::next(i.iterator_base));
+            }
+        };
+        template <typename Iterator>
+        struct prior
+        {
+            typedef typename Derived_::template make<
+                typename result_of::prior<
+                    typename Iterator::iterator_base_type
+                >::type>::type
+            type;
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::prior(i.iterator_base));
+            }
+        };
+    };
+}}
+namespace boost { namespace fusion
+{
+    template <typename Iterator_, bool IsLast>
+    struct pop_back_iterator
+        : iterator_adapter<
+            pop_back_iterator<Iterator_, IsLast>
+          , Iterator_>
+    {
+        typedef iterator_adapter<
+            pop_back_iterator<Iterator_, IsLast>
+          , Iterator_>
+        base_type;
+        static bool const is_last = IsLast;
+        pop_back_iterator(Iterator_ const& iterator_base)
+            : base_type(iterator_base) {}
+        template <typename BaseIterator>
+        struct make
+        {
+            typedef pop_back_iterator<BaseIterator, is_last> type;
+            static type
+            call(BaseIterator const& i)
+            {
+                return type(i);
+            }
+        };
+        template <typename I, bool IsLast_>
+        struct equal_to_helper
+            : mpl::identity<typename I::iterator_base_type>
+        {};
+        template <typename I>
+        struct equal_to_helper<I, true>
+            : result_of::next<
+                typename I::iterator_base_type>
+        {};
+        template <typename I1, typename I2>
+        struct equal_to
+            : result_of::equal_to<
+                typename equal_to_helper<I1,
+                    (I2::is_last && !I1::is_last)>::type
+              , typename equal_to_helper<I2,
+                    (I1::is_last && !I2::is_last)>::type
+            >
+        {};
+        template <typename First, typename Last>
+        struct distance
+            : mpl::minus<
+                typename result_of::distance<
+                    typename First::iterator_base_type
+                  , typename Last::iterator_base_type
+                >::type
+              , mpl::int_<(Last::is_last?1:0)>
+            >::type
+        {};
+        template <typename Iterator, bool IsLast_>
+        struct prior_impl
+        {
+            typedef typename Iterator::iterator_base_type base_type;
+            typedef typename
+                result_of::prior<base_type>::type
+            base_prior;
+            typedef pop_back_iterator<base_prior, false> type;
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::prior(i.iterator_base));
+            }
+        };
+        template <typename Iterator>
+        struct prior_impl<Iterator, true>
+        {
+            typedef typename Iterator::iterator_base_type base_type;
+            typedef typename
+                result_of::prior<
+                  typename result_of::prior<base_type>::type
+                >::type
+            base_prior;
+            typedef pop_back_iterator<base_prior, false> type;
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::prior(
+                    fusion::prior(i.iterator_base)));
+            }
+        };
+        template <typename Iterator>
+        struct prior : prior_impl<Iterator, Iterator::is_last>
+        {};
+    };
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct pop_back
+        {
+            enum { mpl_assertion_in_line_133 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (result_of::empty<Sequence>))0, 1 ) ) ) };
+            typedef pop_back_iterator<
+                typename begin<Sequence>::type, false>
+            begin_type;
+            typedef pop_back_iterator<
+                typename end<Sequence>::type, true>
+            end_type;
+            typedef
+                iterator_range<begin_type, end_type>
+            type;
+        };
+    }
+    template <typename Sequence>
+    inline typename result_of::pop_back<Sequence const>::type
+    pop_back(Sequence const& seq)
+    {
+        typedef result_of::pop_back<Sequence const> comp;
+        typedef typename comp::begin_type begin_type;
+        typedef typename comp::end_type end_type;
+        typedef typename comp::type result;
+        return result(
+            begin_type(fusion::begin(seq))
+          , end_type(fusion::end(seq))
+        );
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct pop_back_impl;
+    template <>
+    struct pop_back_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::pop_back<Sequence>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct pop_front_impl
+{
+    template< typename Sequence > struct apply
+    ;
+};
+ template<> struct pop_front_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    >
+struct pop_front
+    : pop_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+};
+template<> struct pop_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pop_front< T1 > { }; }; template< typename Tag > struct lambda< pop_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef pop_front< na > result_; typedef pop_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< pop_front< T1 > > : int_<1> { }; template<> struct template_arity< pop_front< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct pop_front
+        {
+            typedef
+                iterator_range<
+                    typename next<
+                        typename begin<Sequence>::type
+                    >::type
+                  , typename end<Sequence>::type
+                >
+            type;
+        };
+    }
+    template <typename Sequence>
+    inline typename result_of::pop_front<Sequence const>::type
+    pop_front(Sequence const& seq)
+    {
+        typedef typename result_of::pop_front<Sequence const>::type result;
+        return result(fusion::next(fusion::begin(seq)), fusion::end(seq));
+    }
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct pop_front_impl;
+    template <>
+    struct pop_front_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::pop_front<Sequence>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct push_back_impl;
+    template <>
+    struct push_back_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename T>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::push_back<Sequence, T>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct push_front_impl;
+    template <>
+    struct push_front_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence, typename T>
+        struct apply
+        {
+            typedef typename
+                fusion::result_of::push_front<Sequence, T>::type
+            result;
+            typedef typename
+                fusion::result_of::convert<
+                    typename fusion::detail::tag_of<Sequence>::type, result>::type
+            type;
+        };
+    };
+}}
+namespace boost { namespace mpl
+{
+    template <typename Tag>
+    struct size_impl;
+    template <>
+    struct size_impl<fusion::fusion_sequence_tag>
+    {
+        template <typename Sequence>
+        struct apply : fusion::result_of::size<Sequence> {};
+    };
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct fold;
+    }
+    template<typename Seq, typename State, typename F>
+    typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State const& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State const& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State& state, F f);
+}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<typename State, typename It, typename F>
+        struct fold_lvalue_state
+          : boost::result_of<
+                F(
+                typename add_reference<typename add_const<State>::type>::type,
+                typename fusion::result_of::deref<It>::type)
+            >
+        {};
+        template<typename Result,int N>
+        struct unrolled_fold
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::next<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::next(it0);
+                typedef typename
+                    result_of::next<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::next(it1);
+                typedef typename
+                    result_of::next<
+                        It2
+                    >::type
+                It3;
+                It3 it3 = fusion::next(it2);
+                typedef typename fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                typedef typename fold_lvalue_state<State1,It1,F>::type State2;
+                State2 const state2=f(state1,fusion::deref(it1));
+                typedef typename fold_lvalue_state<State2,It2,F>::type State3;
+                State3 const state3=f(state2,fusion::deref(it2));
+                return unrolled_fold<
+                    Result
+                  , N-4
+                >::call(
+                    f(state3,fusion::deref(it3)),
+                    fusion::next(it3),
+                    f);
+            }
+        };
+        template<typename Result>
+        struct unrolled_fold<Result,3>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::next<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::next(it0);
+                typedef typename
+                    result_of::next<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::next(it1);
+                typedef typename fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                typedef typename fold_lvalue_state<State1,It1,F>::type State2;
+                State2 const state2=f(state1,fusion::deref(it1));
+                return f(state2,fusion::deref(it2));
+            }
+        };
+        template<typename Result>
+        struct unrolled_fold<Result,2>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                return f(
+                    state1,
+                    fusion::deref( fusion::next(it0)));
+            }
+        };
+        template<typename Result>
+        struct unrolled_fold<Result,1>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                return f(state,
+                    fusion::deref(it0));
+            }
+        };
+        template<typename Result>
+        struct unrolled_fold<Result,0>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0, F)
+            {
+                return static_cast<Result>(state);
+            }
+        };
+        template<typename StateRef, typename It0, typename F, int N>
+        struct result_of_unrolled_fold
+        {
+            typedef typename
+                fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::next<
+                    It0 const
+                >::type
+            it1;
+            typedef typename
+                fold_lvalue_state<
+                    rest1
+                  , it1
+                  , F
+                >::type
+            rest2;
+            typedef typename
+                result_of::next<it1>::type
+            it2;
+            typedef typename
+                fold_lvalue_state<
+                    rest2
+                  , it2
+                  , F
+                >::type
+            rest3;
+            typedef typename
+                result_of::next<it2>::type
+            it3;
+            typedef typename
+                result_of_unrolled_fold<
+                    typename fold_lvalue_state<
+                        rest3
+                      , it3
+                      , F
+                    >::type
+                  , typename result_of::next<
+                        it3
+                    >::type
+                  , F
+                  , N-4
+                >::type
+            type;
+        };
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_fold<
+            StateRef
+          , It0
+          , F
+          , 3
+        >
+        {
+            typedef typename
+                fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::next<
+                    It0 const
+                >::type
+            it1;
+            typedef typename
+                fold_lvalue_state<
+                    typename fold_lvalue_state<
+                        rest1
+                      , it1
+                      , F
+                    >::type
+                  , typename result_of::next<
+                        it1 const
+                    >::type const
+                  , F
+                >::type
+            type;
+        };
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_fold<
+            StateRef
+          , It0
+          , F
+          , 2
+        >
+          : fold_lvalue_state<
+                typename fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+              , typename result_of::next<
+                    It0 const
+                >::type const
+              , F
+            >
+        {};
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_fold<
+            StateRef
+          , It0
+          , F
+          , 1
+        >
+          : fold_lvalue_state<
+                StateRef
+              , It0 const
+              , F
+            >
+        {};
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_fold<
+            StateRef
+          , It0
+          , F
+          , 0
+        >
+        {
+            typedef StateRef type;
+        };
+        template<typename StateRef, typename It0, typename F, int SeqSize>
+        struct result_of_first_unrolledfold
+        {
+            typedef typename
+                result_of_unrolled_fold<
+                    typename boost::result_of<
+                        F(
+                            StateRef,
+                            typename fusion::result_of::deref< It0 const>::type
+                        )
+                    >::type
+                  , typename result_of::next<
+                        It0 const
+                    >::type
+                  , F
+                  , SeqSize-1
+                >::type
+            type;
+        };
+        template<int SeqSize, typename StateRef, typename Seq, typename F>
+        struct fold_impl
+        {
+            typedef typename
+                result_of_first_unrolledfold<
+                    StateRef
+                  , typename result_of::begin<Seq>::type
+                  , F
+                  , SeqSize
+                >::type
+            type;
+            static type
+            call(StateRef state, Seq& seq, F f)
+            {
+                typedef
+                    unrolled_fold<
+                        type
+                      , SeqSize
+                    >
+                unrolled_impl;
+                return unrolled_impl::call(
+                    state,
+                    fusion::begin(seq),
+                    f);
+            }
+        };
+        template<typename StateRef, typename Seq, typename F>
+        struct fold_impl<0,StateRef,Seq,F>
+        {
+            typedef StateRef type;
+            static StateRef
+            call(StateRef state, Seq&, F)
+            {
+                return static_cast<StateRef>(state);
+            }
+        };
+        template<typename Seq, typename State, typename F, bool IsSegmented>
+        struct result_of_fold
+          : fold_impl<
+                result_of::size<Seq>::value
+              , typename add_reference<
+                    typename add_const<State>::type
+                >::type
+              , Seq
+              , F
+            >
+        {};
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct fold
+          : detail::result_of_fold<
+                Seq
+              , State
+              , F
+              , traits::is_segmented<Seq>::type::value
+            >
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State const& state, F f)
+    {
+        return result_of::fold<Seq,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State const& state, F f)
+    {
+        return result_of::fold<Seq const,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State& state, F f)
+    {
+        return result_of::fold<Seq,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State& state, F f)
+    {
+        return result_of::fold<Seq const,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Fun>
+    struct segmented_fold_fun
+    {
+        explicit segmented_fold_fun(Fun const& f)
+          : fun(f)
+        {}
+        Fun const& fun;
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef typename result_of::fold<Sequence, State, Fun>::type type;
+            typedef mpl::true_ continue_type;
+            static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
+            {
+                return fusion::fold(seq, state, fun.fun);
+            }
+        };
+    };
+    template <typename Sequence, typename State, typename Fun, bool IsSegmented>
+    struct result_of_fold;
+    template <typename Sequence, typename State, typename Fun>
+    struct result_of_fold<Sequence, State, Fun, true>
+    {
+        typedef
+            typename result_of::segmented_fold_until<
+                Sequence,
+                State,
+                segmented_fold_fun<Fun>
+            >::type
+        type;
+        static type call(State& state, Sequence& seq, Fun fun)
+        {
+            return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct forward_traversal_tag;
+    struct bidirectional_traversal_tag;
+    struct random_access_traversal_tag;
+    namespace detail
+    {
+        template<typename Tag1, typename Tag2,
+            bool Tag1Stricter = boost::is_convertible<Tag2,Tag1>::value>
+        struct stricter_traversal
+        {
+            typedef Tag1 type;
+        };
+        template<typename Tag1, typename Tag2>
+        struct stricter_traversal<Tag1,Tag2,false>
+        {
+            typedef Tag2 type;
+        };
+        struct strictest_traversal_impl
+        {
+            template<typename Sig>
+            struct result;
+            template<typename StrictestSoFar, typename Next>
+            struct result<strictest_traversal_impl(StrictestSoFar, Next)>
+            {
+                typedef typename remove_reference<Next>::type next_value;
+                typedef typename remove_reference<StrictestSoFar>::type strictest_so_far;
+                typedef strictest_so_far tag1;
+                typedef typename traits::category_of<next_value>::type tag2;
+                typedef typename stricter_traversal<tag1,tag2>::type type;
+            };
+        };
+        template<typename Sequence>
+        struct strictest_traversal
+            : result_of::fold<
+            Sequence, fusion::random_access_traversal_tag,
+            strictest_traversal_impl>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct transform_view_tag;
+    struct transform_view2_tag;
+    struct fusion_sequence_tag;
+    template <typename Sequence1, typename Sequence2, typename F>
+    struct transform_view : sequence_base<transform_view<Sequence1, Sequence2, F> >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((result_of::size<Sequence1>::value == result_of::size<Sequence2>::value) == 0 ? false : true) >)> boost_static_assert_typedef_40;
+        typedef transform_view2_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::true_ is_view;
+        typedef typename traits::category_of<Sequence1>::type category1;
+        typedef typename traits::category_of<Sequence2>::type category2;
+        typedef typename detail::strictest_traversal<
+            fusion::vector2<Sequence1, Sequence2> >::type category;
+        typedef typename result_of::begin<Sequence1>::type first1_type;
+        typedef typename result_of::begin<Sequence2>::type first2_type;
+        typedef typename result_of::end<Sequence1>::type last1_type;
+        typedef typename result_of::end<Sequence2>::type last2_type;
+        typedef typename result_of::size<Sequence1>::type size;
+        typedef Sequence1 sequence1_type;
+        typedef Sequence2 sequence2_type;
+        typedef F transform_type;
+        transform_view(Sequence1& in_seq1, Sequence2& in_seq2, F const& binop)
+            : f(binop)
+            , seq1(in_seq1)
+            , seq2(in_seq2)
+        {}
+        first1_type first1() const { return fusion::begin(seq1); }
+        first2_type first2() const { return fusion::begin(seq2); }
+        last1_type last1() const { return fusion::end(seq1); }
+        last2_type last2() const { return fusion::end(seq2); }
+        transform_type f;
+        typename mpl::if_<traits::is_view<Sequence1>, Sequence1, Sequence1&>::type seq1;
+        typename mpl::if_<traits::is_view<Sequence2>, Sequence2, Sequence2&>::type seq2;
+    private:
+        transform_view& operator= (transform_view const&);
+    };
+    template <typename Sequence, typename F>
+    struct transform_view<Sequence, F> : sequence_base<transform_view<Sequence, F> >
+    {
+        typedef transform_view_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::true_ is_view;
+        typedef typename traits::category_of<Sequence>::type category;
+        typedef typename result_of::begin<Sequence>::type first_type;
+        typedef typename result_of::end<Sequence>::type last_type;
+        typedef typename result_of::size<Sequence>::type size;
+        typedef Sequence sequence_type;
+        typedef F transform_type;
+        transform_view(Sequence& in_seq, F const& in_f)
+            : seq(in_seq)
+            , f(in_f)
+        {}
+        first_type first() const { return fusion::begin(seq); }
+        last_type last() const { return fusion::end(seq); }
+        typename mpl::if_<traits::is_view<Sequence>, Sequence, Sequence&>::type seq;
+        transform_type f;
+    private:
+        transform_view& operator= (transform_view const&);
+    };
+}}
+namespace boost { namespace fusion { namespace traits
+{
+    template <typename Seq1, typename Seq2, typename Enable = void>
+    struct enable_equality
+        : mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
+    {};
+    template <typename Seq1, typename Seq2, typename Enable = void>
+    struct enable_comparison
+        : mpl::and_<
+            mpl::or_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >
+          , mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> >
+        >
+    {};
+}}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr, long Pos>
+        struct expr_iterator
+          : fusion::iterator_base<expr_iterator<Expr, Pos> >
+        {
+            typedef Expr expr_type;
+            typedef typename Expr::proto_tag proto_tag;
+            static const long index = Pos;
+            typedef fusion::random_access_traversal_tag category;
+            typedef tag::proto_expr_iterator fusion_tag;
+            expr_iterator(Expr &e)
+              : expr(e)
+            {}
+            Expr &expr;
+        };
+        template<typename Expr>
+        struct flat_view
+        {
+            typedef Expr expr_type;
+            typedef typename Expr::proto_tag proto_tag;
+            typedef fusion::forward_traversal_tag category;
+            typedef tag::proto_flat_view fusion_tag;
+            explicit flat_view(Expr &e)
+              : expr_(e)
+            {}
+            Expr &expr_;
+        };
+        template<typename Tag>
+        struct as_element
+        {
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+              : result<This(Expr const &)>
+            {};
+            template<typename This, typename Expr>
+            struct result<This(Expr &)>
+              : mpl::if_c<
+                    is_same<Tag, typename Expr::proto_tag>::value
+                  , flat_view<Expr>
+                  , fusion::single_view<Expr &>
+                >
+            {};
+            template<typename Expr>
+            typename result<as_element(Expr &)>::type const
+            operator ()(Expr &e) const
+            {
+                return typename result<as_element(Expr &)>::type(e);
+            }
+            template<typename Expr>
+            typename result<as_element(Expr const &)>::type const
+            operator ()(Expr const &e) const
+            {
+                return typename result<as_element(Expr const &)>::type(e);
+            }
+        };
+    }
+    namespace result_of
+    {
+        template<typename Expr>
+        struct flatten
+          : flatten<Expr const &>
+        {};
+        template<typename Expr>
+        struct flatten<Expr &>
+        {
+            typedef detail::flat_view<Expr> type;
+        };
+    }
+    namespace functional
+    {
+        struct flatten
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+              : result<This(Expr const &)>
+            {};
+            template<typename This, typename Expr>
+            struct result<This(Expr &)>
+            {
+                typedef proto::detail::flat_view<Expr> type;
+            };
+            template<typename Expr>
+            proto::detail::flat_view<Expr> const
+            operator ()(Expr &e) const
+            {
+                return proto::detail::flat_view<Expr>(e);
+            }
+            template<typename Expr>
+            proto::detail::flat_view<Expr const> const
+            operator ()(Expr const &e) const
+            {
+                return proto::detail::flat_view<Expr const>(e);
+            }
+        };
+    }
+    template<typename Expr>
+    proto::detail::flat_view<Expr> const
+    flatten(Expr &e)
+    {
+        return proto::detail::flat_view<Expr>(e);
+    }
+    template<typename Expr>
+    proto::detail::flat_view<Expr const> const
+    flatten(Expr const &e)
+    {
+        return proto::detail::flat_view<Expr const>(e);
+    }
+    template<typename Context>
+    struct eval_fun
+      : proto::callable
+    {
+        explicit eval_fun(Context &ctx)
+          : ctx_(ctx)
+        {}
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Expr>
+        struct result<This(Expr)>
+          : result<This(Expr const &)>
+        {};
+        template<typename This, typename Expr>
+        struct result<This(Expr &)>
+          : proto::result_of::eval<Expr, Context>
+        {};
+        template<typename Expr>
+        typename proto::result_of::eval<Expr, Context>::type
+        operator ()(Expr &e) const
+        {
+            return proto::eval(e, this->ctx_);
+        }
+        template<typename Expr>
+        typename proto::result_of::eval<Expr const, Context>::type
+        operator ()(Expr const &e) const
+        {
+            return proto::eval(e, this->ctx_);
+        }
+    private:
+        Context &ctx_;
+    };
+    template<typename Context>
+    struct is_callable<eval_fun<Context> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace fusion
+{
+    namespace extension
+    {
+        template<typename Tag>
+        struct is_sequence_impl;
+        template<>
+        struct is_sequence_impl<proto::tag::proto_flat_view>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+        template<>
+        struct is_sequence_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+        template<typename Tag>
+        struct is_view_impl;
+        template<>
+        struct is_view_impl<proto::tag::proto_flat_view>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::true_
+            {};
+        };
+        template<>
+        struct is_view_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::false_
+            {};
+        };
+        template<typename Tag>
+        struct value_of_impl;
+        template<>
+        struct value_of_impl<proto::tag::proto_expr_iterator>
+        {
+            template<
+                typename Iterator
+              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        typename Iterator::expr_type
+                      , Iterator::index
+                    >::value_type
+                type;
+            };
+            template<typename Iterator>
+            struct apply<Iterator, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        typename Iterator::expr_type
+                    >::value_type
+                type;
+            };
+        };
+        template<typename Tag>
+        struct deref_impl;
+        template<>
+        struct deref_impl<proto::tag::proto_expr_iterator>
+        {
+            template<
+                typename Iterator
+              , long Arity = proto::arity_of<typename Iterator::expr_type>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        typename Iterator::expr_type &
+                      , Iterator::index
+                    >::type
+                type;
+                static type call(Iterator const &iter)
+                {
+                    return proto::child_c<Iterator::index>(iter.expr);
+                }
+            };
+            template<typename Iterator>
+            struct apply<Iterator, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        typename Iterator::expr_type &
+                    >::type
+                type;
+                static type call(Iterator const &iter)
+                {
+                    return proto::value(iter.expr);
+                }
+            };
+        };
+        template<typename Tag>
+        struct advance_impl;
+        template<>
+        struct advance_impl<proto::tag::proto_expr_iterator>
+        {
+            template<typename Iterator, typename N>
+            struct apply
+            {
+                typedef
+                    typename proto::detail::expr_iterator<
+                        typename Iterator::expr_type
+                      , Iterator::index + N::value
+                    >
+                type;
+                static type call(Iterator const &iter)
+                {
+                    return type(iter.expr);
+                }
+            };
+        };
+        template<typename Tag>
+        struct distance_impl;
+        template<>
+        struct distance_impl<proto::tag::proto_expr_iterator>
+        {
+            template<typename IteratorFrom, typename IteratorTo>
+            struct apply
+              : mpl::long_<IteratorTo::index - IteratorFrom::index>
+            {};
+        };
+        template<typename Tag>
+        struct next_impl;
+        template<>
+        struct next_impl<proto::tag::proto_expr_iterator>
+        {
+            template<typename Iterator>
+            struct apply
+              : advance_impl<proto::tag::proto_expr_iterator>::template apply<Iterator, mpl::long_<1> >
+            {};
+        };
+        template<typename Tag>
+        struct prior_impl;
+        template<>
+        struct prior_impl<proto::tag::proto_expr_iterator>
+        {
+            template<typename Iterator>
+            struct apply
+              : advance_impl<proto::tag::proto_expr_iterator>::template apply<Iterator, mpl::long_<-1> >
+            {};
+        };
+        template<typename Tag>
+        struct category_of_impl;
+        template<>
+        struct category_of_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef random_access_traversal_tag type;
+            };
+        };
+        template<typename Tag>
+        struct size_impl;
+        template<>
+        struct size_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+              : mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c>
+            {};
+        };
+        template<typename Tag>
+        struct begin_impl;
+        template<>
+        struct begin_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef proto::detail::expr_iterator<Sequence, 0> type;
+                static type call(Sequence &seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+        template<typename Tag>
+        struct end_impl;
+        template<>
+        struct end_impl<proto::tag::proto_expr>
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef
+                    proto::detail::expr_iterator<
+                        Sequence
+                      , 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c
+                    >
+                type;
+                static type call(Sequence &seq)
+                {
+                    return type(seq);
+                }
+            };
+        };
+        template<typename Tag>
+        struct value_at_impl;
+        template<>
+        struct value_at_impl<proto::tag::proto_expr>
+        {
+            template<
+                typename Sequence
+              , typename Index
+              , long Arity = proto::arity_of<Sequence>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        Sequence
+                      , Index::value
+                    >::value_type
+                type;
+            };
+            template<typename Sequence, typename Index>
+            struct apply<Sequence, Index, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        Sequence
+                    >::value_type
+                type;
+            };
+        };
+        template<typename Tag>
+        struct at_impl;
+        template<>
+        struct at_impl<proto::tag::proto_expr>
+        {
+            template<
+                typename Sequence
+              , typename Index
+              , long Arity = proto::arity_of<Sequence>::value
+            >
+            struct apply
+            {
+                typedef
+                    typename proto::result_of::child_c<
+                        Sequence &
+                      , Index::value
+                    >::type
+                type;
+                static type call(Sequence &seq)
+                {
+                    return proto::child_c<Index::value>(seq);
+                }
+            };
+            template<typename Sequence, typename Index>
+            struct apply<Sequence, Index, 0>
+            {
+                typedef
+                    typename proto::result_of::value<
+                        Sequence &
+                    >::type
+                type;
+                static type call(Sequence &seq)
+                {
+                    return proto::value(seq);
+                }
+            };
+        };
+        template<typename Tag>
+        struct is_segmented_impl;
+        template<>
+        struct is_segmented_impl<proto::tag::proto_flat_view>
+        {
+            template<typename Iterator>
+            struct apply
+              : mpl::true_
+            {};
+        };
+        template<typename Tag>
+        struct segments_impl;
+        template<>
+        struct segments_impl<proto::tag::proto_flat_view>
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::proto_tag proto_tag;
+                typedef fusion::transform_view<
+                    typename Sequence::expr_type
+                  , proto::detail::as_element<proto_tag>
+                > type;
+                static type call(Sequence &sequence)
+                {
+                    return type(sequence.expr_, proto::detail::as_element<proto_tag>());
+                }
+            };
+        };
+        template<>
+        struct category_of_impl<proto::tag::proto_flat_view>
+        {
+            template<typename Sequence>
+            struct apply
+            {
+                typedef forward_traversal_tag type;
+            };
+        };
+    }
+    namespace traits
+    {
+        template<typename Seq1, typename Seq2>
+        struct enable_equality<
+            Seq1
+          , Seq2
+          , typename enable_if_c<
+                mpl::or_<
+                    proto::is_expr<Seq1>
+                  , proto::is_expr<Seq2>
+                >::value
+            >::type
+        >
+            : mpl::false_
+        {};
+        template<typename Seq1, typename Seq2>
+        struct enable_comparison<
+            Seq1
+          , Seq2
+          , typename enable_if_c<
+                mpl::or_<
+                    proto::is_expr<Seq1>
+                  , proto::is_expr<Seq2>
+                >::value
+            >::type
+        >
+          : mpl::false_
+        {};
+    }
+}}
+namespace boost { namespace mpl
+{
+    template<typename Tag, typename Args, long Arity>
+    struct sequence_tag< proto::expr<Tag, Args, Arity> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+    template<typename Tag, typename Args, long Arity>
+    struct sequence_tag< proto::basic_expr<Tag, Args, Arity> >
+    {
+        typedef fusion::fusion_sequence_tag type;
+    };
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct contains_impl;
+template< typename Sequence, typename T > struct contains;
+}}
+namespace boost { namespace mpl { namespace aux {
+struct map_tag;
+}}}
+namespace boost { namespace mpl {
+template< typename Tag > struct order_impl;
+template< typename AssociativeSequence, typename Key > struct order;
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename T > static T const& ptr_to_ref(T*);
+}}}
+namespace boost { namespace mpl {
+template< typename Seq, typename Key > struct x_order_impl
+    : long_<
+          sizeof( Seq::order_by_key_( aux::ptr_to_ref(static_cast<Seq*>(0)), static_cast<aux::type_wrapper<Key>*>(0) )
+              )
+        >
+{
+};
+template< typename Tag >
+struct order_impl
+{
+    template< typename Seq, typename Key > struct apply
+        : if_<
+              typename has_key_impl<Tag>::template apply<Seq,Key>
+            , x_order_impl<Seq,Key>
+            , void_
+            >::type
+    {
+    };
+};
+ template<> struct order_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template< typename Map, typename Key >
+struct m_at
+{
+    typedef aux::type_wrapper<Key> key_;
+    typedef __typeof__( Map::value_by_key_( aux::ptr_to_ref(static_cast<Map*>(0)), static_cast<key_*>(0) )
+          ) type;
+};
+template<>
+struct at_impl< aux::map_tag >
+{
+    template< typename Map, typename Key > struct apply
+        : aux::wrapped_type< typename m_at<
+              Map
+            , Key
+            >::type >
+    {
+    };
+};
+template< typename Map, long order >
+struct item_by_order_impl
+{
+    typedef __typeof__( Map::item_by_order_( aux::ptr_to_ref(static_cast<Map*>(0)), static_cast<long_<order>*>(0) )
+          ) type;
+};
+template< typename Map, long order >
+struct item_by_order
+    : aux::wrapped_type<
+          typename item_by_order_impl<Map,order>::type
+        >
+{
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct contains_impl< aux::map_tag >
+{
+    template< typename Map, typename Pair > struct apply
+        : is_same<
+              typename at_impl<aux::map_tag>::apply<
+                  Map
+                , typename Pair::first
+                >::type
+            , typename Pair::second
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T1 = na
+    , typename T2 = na
+    >
+struct pair
+{
+    typedef pair type;
+    typedef T1 first;
+    typedef T2 second;
+};
+template<
+      typename P = na
+    >
+struct first
+{
+    typedef typename P::first type;
+};
+template<
+      typename P = na
+    >
+struct second
+{
+    typedef typename P::second type;
+};
+template<> struct pair< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair< na , na > result_; typedef pair< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair< na , na > > : int_<-1> { }; }
+template<> struct first< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : first< T1 > { }; }; template< typename Tag > struct lambda< first< na > , Tag , int_<-1> > { typedef false_ is_le; typedef first< na > result_; typedef first< na > type; }; namespace aux { template< typename T1 > struct template_arity< first< T1 > > : int_<1> { }; template<> struct template_arity< first< na > > : int_<-1> { }; }
+template<> struct second< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : second< T1 > { }; }; template< typename Tag > struct lambda< second< na > , Tag , int_<-1> > { typedef false_ is_le; typedef second< na > result_; typedef second< na > type; }; namespace aux { template< typename T1 > struct template_arity< second< T1 > > : int_<1> { }; template<> struct template_arity< second< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename Dummy = na > struct map0
+{
+    typedef map0 type;
+    typedef aux::map_tag tag;
+    typedef void_ key_;
+    typedef long_<1> order;
+    typedef long_<0> size;
+    static aux::type_wrapper<void_> value_by_key_(map0<> const&, void const volatile*);
+    static aux::type_wrapper<void_> item_by_order_(map0<> const&, long_<1>*);
+    static aux::no_tag order_by_key_(map0<> const&, void const volatile*);
+};
+}}
+namespace boost { namespace mpl {
+template< typename Key, typename T, typename Base >
+struct m_item
+    : Base
+{
+    typedef Key key_;
+    typedef pair<Key,T> item;
+    typedef Base base;
+    typedef typename next< typename Base::size >::type size;
+    typedef typename next< typename Base::order >::type order;
+    typedef char (&order_tag_)[order::value];
+    static aux::type_wrapper<T> value_by_key_(m_item const&, aux::type_wrapper<Key>*); using Base::value_by_key_;
+    static aux::type_wrapper<item> item_by_order_(m_item const&, order*); using Base::item_by_order_;
+    static order_tag_ order_by_key_(m_item const&, aux::type_wrapper<Key>*); using Base::order_by_key_;
+};
+template< typename Key, typename Base >
+struct m_mask
+    : Base
+{
+    typedef void_ key_;
+    typedef Base base;
+    typedef typename prior< typename Base::size >::type size;
+    typedef typename x_order_impl<Base,Key>::type key_order_;
+    static aux::type_wrapper<void_> value_by_key_(m_mask const&, aux::type_wrapper<Key>*); using Base::value_by_key_;
+    static aux::type_wrapper<void_> item_by_order_(m_mask const&, key_order_*); using Base::item_by_order_;
+};
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Map, typename Pair >
+struct map_insert_impl
+    : if_<
+          contains_impl<aux::map_tag>::apply<Map,Pair>
+        , Map
+        , m_item<
+              typename Pair::first
+            , typename Pair::second
+            , Map
+            >
+        >
+{
+};
+}
+template<>
+struct insert_impl< aux::map_tag >
+{
+    template<
+          typename Map
+        , typename PosOrKey
+        , typename KeyOrNA
+        >
+    struct apply
+        : aux::map_insert_impl<
+              Map
+            , typename if_na<KeyOrNA,PosOrKey>::type
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct has_key_impl< aux::map_tag >
+{
+    template< typename Map, typename Key > struct apply
+        : is_not_void_<
+              typename at_impl<aux::map_tag>
+                ::apply<Map,Key>::type
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    >
+struct base
+{
+    typedef typename T::base type;
+};
+template<> struct base< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : base< T1 > { }; }; template< typename Tag > struct lambda< base< na > , Tag , int_<-1> > { typedef false_ is_le; typedef base< na > result_; typedef base< na > type; }; namespace aux { template< typename T1 > struct template_arity< base< T1 > > : int_<1> { }; template<> struct template_arity< base< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct erase_key_impl< aux::map_tag >
+{
+    template<
+          typename Map
+        , typename Key
+        >
+    struct apply
+        : eval_if<
+              has_key_impl<aux::map_tag>::apply<Map,Key>
+            , eval_if<
+                  is_same< Key,typename Map::key_ >
+                , base<Map>
+                , identity< m_mask<Key,Map> >
+                >
+            , identity<Map>
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct erase_impl< aux::map_tag >
+{
+    template<
+          typename Map
+        , typename Pos
+        , typename unused_
+        >
+    struct apply
+        : erase_key_impl<aux::map_tag>
+            ::apply<Map,typename Pos::type::first>
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct key_type_impl;
+template< typename AssociativeSequence, typename T > struct key_type;
+}}
+namespace boost {
+namespace mpl {
+template<>
+struct key_type_impl< aux::map_tag >
+{
+    template< typename Map, typename T > struct apply
+        : first<T>
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct value_type_impl;
+template< typename AssociativeSequence, typename T > struct value_type;
+}}
+namespace boost {
+namespace mpl {
+template<>
+struct value_type_impl< aux::map_tag >
+{
+    template< typename Map, typename T > struct apply
+        : second<T>
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct clear_impl< aux::map_tag >
+{
+    template< typename Map > struct apply
+    {
+        typedef map0<> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct size_impl< aux::map_tag >
+{
+    template< typename Map > struct apply
+        : Map::size
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct empty_impl< aux::map_tag >
+{
+    template< typename Map > struct apply
+        : not_< typename Map::size >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Map
+    , long order
+    , long max_order
+    >
+struct next_order
+    : if_<
+          is_void_< typename item_by_order<Map,order>::type >
+        , next_order<Map,(order+1),max_order>
+        , long_<order>
+        >::type
+{
+};
+template<
+      typename Map
+    , long max_order
+    >
+struct next_order<Map,max_order,max_order>
+    : long_<max_order>
+{
+};
+template< typename Map, long order, long max_order >
+struct m_iter
+{
+    typedef forward_iterator_tag category;
+    typedef typename item_by_order<Map,order>::type type;
+};
+template< typename Map, long max_order >
+struct m_iter<Map,max_order,max_order>
+{
+    typedef forward_iterator_tag category;
+};
+template< typename Map, long order, long max_order >
+struct next< m_iter<Map,order,max_order> >
+{
+    typedef m_iter<
+          Map
+        , next_order<Map,order+1,max_order>::value
+        , max_order
+        > type;
+};
+template< typename Map, long max_order >
+struct next< m_iter<Map,max_order,max_order> >
+{
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct begin_impl< aux::map_tag >
+{
+    template< typename Map > struct apply
+    {
+        typedef typename next< typename Map::order >::type max_order_;
+        typedef m_iter<
+              Map
+            , next_order<Map,1,max_order_::value>::value
+            , max_order_::value
+            > type;
+    };
+};
+template<>
+struct end_impl< aux::map_tag >
+{
+    template< typename Map > struct apply
+    {
+        typedef typename next< typename Map::order >::type max_order_;
+        typedef m_iter< Map,max_order_::value,max_order_::value > type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename P0
+    >
+struct map1
+    : m_item<
+          typename P0::first
+        , typename P0::second
+        , map0< >
+        >
+{
+    typedef map1 type;
+};
+template<
+      typename P0, typename P1
+    >
+struct map2
+    : m_item<
+          typename P1::first
+        , typename P1::second
+        , map1<P0>
+        >
+{
+    typedef map2 type;
+};
+template<
+      typename P0, typename P1, typename P2
+    >
+struct map3
+    : m_item<
+          typename P2::first
+        , typename P2::second
+        , map2< P0,P1 >
+        >
+{
+    typedef map3 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3
+    >
+struct map4
+    : m_item<
+          typename P3::first
+        , typename P3::second
+        , map3< P0,P1,P2 >
+        >
+{
+    typedef map4 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    >
+struct map5
+    : m_item<
+          typename P4::first
+        , typename P4::second
+        , map4< P0,P1,P2,P3 >
+        >
+{
+    typedef map5 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5
+    >
+struct map6
+    : m_item<
+          typename P5::first
+        , typename P5::second
+        , map5< P0,P1,P2,P3,P4 >
+        >
+{
+    typedef map6 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6
+    >
+struct map7
+    : m_item<
+          typename P6::first
+        , typename P6::second
+        , map6< P0,P1,P2,P3,P4,P5 >
+        >
+{
+    typedef map7 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7
+    >
+struct map8
+    : m_item<
+          typename P7::first
+        , typename P7::second
+        , map7< P0,P1,P2,P3,P4,P5,P6 >
+        >
+{
+    typedef map8 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8
+    >
+struct map9
+    : m_item<
+          typename P8::first
+        , typename P8::second
+        , map8< P0,P1,P2,P3,P4,P5,P6,P7 >
+        >
+{
+    typedef map9 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    >
+struct map10
+    : m_item<
+          typename P9::first
+        , typename P9::second
+        , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 >
+        >
+{
+    typedef map10 type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10
+    >
+struct map11
+    : m_item<
+          typename P10::first
+        , typename P10::second
+        , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 >
+        >
+{
+    typedef map11 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11
+    >
+struct map12
+    : m_item<
+          typename P11::first
+        , typename P11::second
+        , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 >
+        >
+{
+    typedef map12 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12
+    >
+struct map13
+    : m_item<
+          typename P12::first
+        , typename P12::second
+        , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 >
+        >
+{
+    typedef map13 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13
+    >
+struct map14
+    : m_item<
+          typename P13::first
+        , typename P13::second
+        , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 >
+        >
+{
+    typedef map14 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    >
+struct map15
+    : m_item<
+          typename P14::first
+        , typename P14::second
+        , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 >
+        >
+{
+    typedef map15 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    , typename P15
+    >
+struct map16
+    : m_item<
+          typename P15::first
+        , typename P15::second
+        , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 >
+        >
+{
+    typedef map16 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    , typename P15, typename P16
+    >
+struct map17
+    : m_item<
+          typename P16::first
+        , typename P16::second
+        , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 >
+        >
+{
+    typedef map17 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    , typename P15, typename P16, typename P17
+    >
+struct map18
+    : m_item<
+          typename P17::first
+        , typename P17::second
+        , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 >
+        >
+{
+    typedef map18 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    , typename P15, typename P16, typename P17, typename P18
+    >
+struct map19
+    : m_item<
+          typename P18::first
+        , typename P18::second
+        , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 >
+        >
+{
+    typedef map19 type;
+};
+template<
+      typename P0, typename P1, typename P2, typename P3, typename P4
+    , typename P5, typename P6, typename P7, typename P8, typename P9
+    , typename P10, typename P11, typename P12, typename P13, typename P14
+    , typename P15, typename P16, typename P17, typename P18, typename P19
+    >
+struct map20
+    : m_item<
+          typename P19::first
+        , typename P19::second
+        , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 >
+        >
+{
+    typedef map20 type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
+    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
+    , typename T12 = na, typename T13 = na, typename T14 = na
+    , typename T15 = na, typename T16 = na, typename T17 = na
+    , typename T18 = na, typename T19 = na
+    >
+struct map;
+template<
+    >
+struct map<
+          na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map0< >
+{
+    typedef map0< >::type type;
+};
+template<
+      typename T0
+    >
+struct map<
+          T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map1<T0>
+{
+    typedef typename map1<T0>::type type;
+};
+template<
+      typename T0, typename T1
+    >
+struct map<
+          T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map2< T0,T1 >
+{
+    typedef typename map2< T0,T1 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2
+    >
+struct map<
+          T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map3< T0,T1,T2 >
+{
+    typedef typename map3< T0,T1,T2 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct map<
+          T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map4< T0,T1,T2,T3 >
+{
+    typedef typename map4< T0,T1,T2,T3 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct map<
+          T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map5< T0,T1,T2,T3,T4 >
+{
+    typedef typename map5< T0,T1,T2,T3,T4 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map6< T0,T1,T2,T3,T4,T5 >
+{
+    typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map7< T0,T1,T2,T3,T4,T5,T6 >
+{
+    typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map8< T0,T1,T2,T3,T4,T5,T6,T7 >
+{
+    typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+{
+    typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+{
+    typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
+        , na, na, na
+        >
+    : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+{
+    typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
+        , na, na, na, na
+        >
+    : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+{
+    typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
+        , na, na, na, na
+        >
+    : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+{
+    typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
+        , na, na, na, na
+        >
+    : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+{
+    typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
+        , na, na, na, na
+        >
+    : map15<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        >
+{
+    typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, na, na, na, na
+        >
+    : map16<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15
+        >
+{
+    typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, na, na, na
+        >
+    : map17<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16
+        >
+{
+    typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, na, na
+        >
+    : map18<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17
+        >
+{
+    typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct map<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, na
+        >
+    : map19<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18
+        >
+{
+    typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct map
+    : map20<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, T19
+        >
+{
+    typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
+};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        inline __attribute__ ((always_inline))
+        T &as_lvalue(T &t)
+        {
+            return t;
+        }
+        template<typename T>
+        inline __attribute__ ((always_inline))
+        T const &as_lvalue(T const &t)
+        {
+            return t;
+        }
+    }
+}}
+namespace boost { namespace proto { namespace detail
+{
+    template<typename T>
+    struct normalize_arg
+    {
+        typedef T type;
+        typedef T const &reference;
+    };
+    template<typename T>
+    struct normalize_arg<T &>
+    {
+        typedef T type;
+        typedef T const &reference;
+    };
+    template<typename T>
+    struct normalize_arg<T const &>
+    {
+        typedef T type;
+        typedef T const &reference;
+    };
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> >
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> &>
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> const &>
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+    template<typename T>
+    struct arg
+    {
+        typedef T const &type;
+        arg(type t)
+          : value(t)
+        {}
+        operator type() const
+        {
+            return this->value;
+        }
+        type operator()() const
+        {
+            return *this;
+        }
+    private:
+        arg &operator =(arg const &);
+        type value;
+    };
+    template<typename T>
+    struct arg<T &>
+    {
+        typedef T &type;
+        arg(type t)
+          : value(t)
+        {}
+        operator type() const
+        {
+            return this->value;
+        }
+        type operator()() const
+        {
+            return *this;
+        }
+    private:
+        arg &operator =(arg const &);
+        type value;
+    };
+    template<typename T, typename Void = void>
+    struct is_poly_function
+      : mpl::false_
+    {};
+    template<typename T>
+    struct is_poly_function<T, typename T::is_poly_function_base_>
+      : mpl::true_
+    {};
+    struct poly_function_base
+    {
+        typedef void is_poly_function_base_;
+    };
+    template<typename Derived, typename NullaryResult = void>
+    struct poly_function
+      : poly_function_base
+    {
+        template<typename Sig>
+        struct result;
+        template<typename This>
+        struct result<This()>
+          : Derived::template impl<>
+        {
+            typedef typename result::result_type type;
+        };
+        NullaryResult operator()() const
+        {
+            result<Derived const()> impl;
+            return impl();
+        }
+    template<typename This , typename A0>
+    struct result<This(A0)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0>
+    typename result<
+        Derived const(
+            A0 const &
+        )
+    >::type
+    operator ()(A0 const &a0) const
+    {
+        result<
+            Derived const(
+                A0 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0));
+    }
+    template<typename This , typename A0 , typename A1>
+    struct result<This(A0 , A1)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1>
+    typename result<
+        Derived const(
+            A0 const & , A1 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2>
+    struct result<This(A0 , A1 , A2)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
+    struct result<This(A0 , A1 , A2 , A3)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct result<This(A0 , A1 , A2 , A3 , A4)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type , typename normalize_arg<A9 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8) , static_cast<typename normalize_arg<A9 const &> ::reference>(a9));
+    }
+    };
+    template<typename T>
+    struct wrap_t;
+    typedef char poly_function_t;
+    typedef char (&mono_function_t)[2];
+    typedef char (&unknown_function_t)[3];
+    template<typename T> poly_function_t test_poly_function(T *, wrap_t<typename T::is_poly_function_base_> * = 0);
+    template<typename T> mono_function_t test_poly_function(T *, wrap_t<typename T::result_type> * = 0);
+    template<typename T> unknown_function_t test_poly_function(T *, ...);
+    template<typename Fun, typename Sig, typename Switch = mpl::size_t<sizeof(test_poly_function<Fun>(0,0))> >
+    struct poly_function_traits
+    {
+        typedef typename Fun::template result<Sig>::type result_type;
+        typedef Fun function_type;
+    };
+    template<typename Fun, typename Sig>
+    struct poly_function_traits<Fun, Sig, mpl::size_t<sizeof(mono_function_t)> >
+    {
+        typedef typename Fun::result_type result_type;
+        typedef Fun function_type;
+    };
+    template<typename PolyFunSig, bool IsPolyFunction>
+    struct as_mono_function_impl;
+    template<typename PolyFunSig>
+    struct as_mono_function;
+    template<typename PolyFun , typename A0>
+    struct poly_function_traits<PolyFun, PolyFun(A0), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0>
+    struct as_mono_function_impl<PolyFun(A0), true>
+    {
+        typedef typename PolyFun::template impl<const A0> type;
+    };
+    template<typename PolyFun , typename A0>
+    struct as_mono_function_impl<PolyFun(A0), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0>
+    struct as_mono_function<PolyFun(A0)>
+      : as_mono_function_impl<PolyFun(A0), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function_impl<PolyFun(A0 , A1), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function_impl<PolyFun(A0 , A1), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function<PolyFun(A0 , A1)>
+      : as_mono_function_impl<PolyFun(A0 , A1), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function<PolyFun(A0 , A1 , A2)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), is_poly_function<PolyFun>::value>
+    {};
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), false>
+    {
+        typedef PolyFun type;
+    };
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), is_poly_function<PolyFun>::value>
+    {};
+}}}
+namespace boost { namespace proto
+{
+    template<typename PrimitiveTransform>
+    struct call
+      : PrimitiveTransform
+    {};
+    template<typename Fun>
+    struct call<Fun()> : transform<call<Fun()> >
+    {
+        template<typename Expr, typename State, typename Data, bool B>
+        struct impl2
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename boost::tr1_result_of<Fun()>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator()(
+                typename impl2::expr_param
+              , typename impl2::state_param
+              , typename impl2::data_param
+            ) const
+            {
+                return Fun()();
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl2<Expr, State, Data, true>
+          : Fun::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : impl2<Expr, State, Data, detail::is_transform_<Fun>::value>
+        {};
+    };
+    template<typename Fun, typename A0>
+    struct call<Fun(A0)> : transform<call<Fun(A0)> >
+    {
+        template<typename Expr, typename State, typename Data, bool B>
+        struct impl2
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename detail::poly_function_traits<Fun, Fun(a0)>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename detail::poly_function_traits<Fun, Fun(a0)>::function_type()(
+                    detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d))
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl2<Expr, State, Data, true>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename Fun::template impl<a0, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename Fun::template impl<a0, State, Data>()(
+                    typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)
+                  , s
+                  , d
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : impl2<Expr, State, Data, detail::is_transform_<Fun>::value>
+        {};
+    };
+    template<typename Fun, typename A0, typename A1>
+    struct call<Fun(A0, A1)> : transform<call<Fun(A0, A1)> >
+    {
+        template<typename Expr, typename State, typename Data, bool B>
+        struct impl2
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
+            typedef typename detail::poly_function_traits<Fun, Fun(a0, a1)>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename detail::poly_function_traits<Fun, Fun(a0, a1)>::function_type()(
+                    detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d))
+                  , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d))
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl2<Expr, State, Data, true>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
+            typedef typename Fun::template impl<a0, a1, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename Fun::template impl<a0, a1, Data>()(
+                    typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)
+                  , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)
+                  , d
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : impl2<Expr, State, Data, detail::is_transform_<Fun>::value>
+        {};
+    };
+    template<typename Fun, typename A0, typename A1, typename A2>
+    struct call<Fun(A0, A1, A2)> : transform<call<Fun(A0, A1, A2)> >
+    {
+        template<typename Expr, typename State, typename Data, bool B>
+        struct impl2
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
+            typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2;
+            typedef typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename detail::poly_function_traits<Fun, Fun(a0, a1, a2)>::function_type()(
+                    detail::as_lvalue(typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d))
+                  , detail::as_lvalue(typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d))
+                  , detail::as_lvalue(typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d))
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl2<Expr, State, Data, true>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data>::result_type a0;
+            typedef typename when<_, A1>::template impl<Expr, State, Data>::result_type a1;
+            typedef typename when<_, A2>::template impl<Expr, State, Data>::result_type a2;
+            typedef typename Fun::template impl<a0, a1, a2>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl2::expr_param e
+              , typename impl2::state_param s
+              , typename impl2::data_param d
+            ) const
+            {
+                return typename Fun::template impl<a0, a1, a2>()(
+                    typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d)
+                  , typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d)
+                  , typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d)
+                );
+            }
+        };
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : impl2<Expr, State, Data, detail::is_transform_<Fun>::value>
+        {};
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct call<Fun(A0 , A1 , A2 , A3)> : transform<call<Fun(A0 , A1 , A2 , A3)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef typename a9::result_type b9;
+            typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits;
+            typedef typename function_traits::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typedef typename function_traits::function_type function_type;
+                return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d)));
+            }
+        };
+    };
+    template<typename Fun>
+    struct is_callable<call<Fun> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        struct is_applyable
+          : mpl::and_<is_callable<T>, is_transform<T> >
+        {};
+        template<typename T, bool HasType = mpl::aux::has_type<T>::value>
+        struct nested_type
+        {
+            typedef typename T::type type;
+        };
+        template<typename T>
+        struct nested_type<T, false>
+        {
+            typedef T type;
+        };
+        template<typename T, bool Applied>
+        struct nested_type_if
+        {
+            typedef T type;
+            static bool const applied = false;
+        };
+        template<typename T>
+        struct nested_type_if<T, true>
+          : nested_type<T>
+        {
+            static bool const applied = true;
+        };
+        template<
+            typename R
+          , typename Expr, typename State, typename Data
+            , long Arity = detail::template_arity<R>::value
+        >
+        struct make_
+        {
+            typedef R type;
+            static bool const applied = false;
+        };
+        template<
+            typename R
+          , typename Expr, typename State, typename Data
+          , bool IsApplyable = is_applyable<R>::value
+        >
+        struct make_if_
+          : make_<R, Expr, State, Data>
+        {};
+        template<typename R, typename Expr, typename State, typename Data>
+        struct make_if_<R, Expr, State, Data, true>
+          : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type>
+        {
+            static bool const applied = true;
+        };
+        template<typename Type, bool IsAggregate = detail::is_aggregate_<Type>::value>
+        struct construct_
+        {
+            typedef Type result_type;
+            inline __attribute__ ((always_inline))
+            Type operator ()() const
+            {
+                return Type();
+            }
+    template<typename A0>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0) const
+    {
+        return Type(a0);
+    }
+    template<typename A0 , typename A1>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1) const
+    {
+        return Type(a0 , a1);
+    }
+    template<typename A0 , typename A1 , typename A2>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+    {
+        return Type(a0 , a1 , a2);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+    {
+        return Type(a0 , a1 , a2 , a3);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+    {
+        return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+        };
+        template<typename Type>
+        struct construct_<Type, true>
+        {
+            typedef Type result_type;
+            inline __attribute__ ((always_inline))
+            Type operator ()() const
+            {
+                return Type();
+            }
+    template<typename A0>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0) const
+    {
+        Type that = {a0};
+        return that;
+    }
+    template<typename A0 , typename A1>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1) const
+    {
+        Type that = {a0 , a1};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+    {
+        Type that = {a0 , a1 , a2};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+    {
+        Type that = {a0 , a1 , a2 , a3};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4 , a5};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+        return that;
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline __attribute__ ((always_inline))
+    Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+    {
+        Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+        return that;
+    }
+        };
+    }
+    template<typename PrimitiveTransform>
+    struct protect : transform<protect<PrimitiveTransform> >
+    {
+        template<typename, typename, typename>
+        struct impl
+        {
+            typedef PrimitiveTransform result_type;
+        };
+    };
+    template<typename Object>
+    struct make : transform<make<Object> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return result_type();
+            }
+        };
+    };
+    namespace detail
+    {
+        template<typename R >
+        struct is_applyable<R()>
+          : mpl::true_
+        {};
+        template<typename R >
+        struct is_applyable<R(*)()>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 0>, true>
+        {
+            typedef proto::expr<T, A, 0> result_type;
+            template<typename A0>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0) const
+            {
+                return result_type::make(a0);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 0>, true>
+        {
+            typedef proto::basic_expr<T, A, 0> result_type;
+            template<typename A0>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0) const
+            {
+                return result_type::make(a0);
+            }
+        };
+        template<typename Type >
+        inline __attribute__ ((always_inline))
+        Type construct()
+        {
+            return construct_<Type>()();
+        }
+    }
+    template<typename Object >
+    struct make<Object()>
+      : transform<make<Object()> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>();
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename> class R
+            , typename A0
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0>
+          , Expr, State, Data
+            , 1
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename> class R
+            , typename A0
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0>
+        struct is_applyable<R(A0)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0>
+        struct is_applyable<R(*)(A0)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 1>, true>
+        {
+            typedef proto::expr<T, A, 1> result_type;
+            template<typename A0>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0) const
+            {
+                return result_type::make(a0);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 1>, true>
+        {
+            typedef proto::basic_expr<T, A, 1> result_type;
+            template<typename A0>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0) const
+            {
+                return result_type::make(a0);
+            }
+        };
+        template<typename Type , typename A0>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0)
+        {
+            return construct_<Type>()(a0);
+        }
+    }
+    template<typename Object , typename A0>
+    struct make<Object(A0)>
+      : transform<make<Object(A0)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename> class R
+            , typename A0 , typename A1
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1>
+          , Expr, State, Data
+            , 2
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename> class R
+            , typename A0 , typename A1
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1>
+        struct is_applyable<R(A0 , A1)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1>
+        struct is_applyable<R(*)(A0 , A1)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 2>, true>
+        {
+            typedef proto::expr<T, A, 2> result_type;
+            template<typename A0 , typename A1>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1) const
+            {
+                return result_type::make(a0 , a1);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 2>, true>
+        {
+            typedef proto::basic_expr<T, A, 2> result_type;
+            template<typename A0 , typename A1>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1) const
+            {
+                return result_type::make(a0 , a1);
+            }
+        };
+        template<typename Type , typename A0 , typename A1>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1)
+        {
+            return construct_<Type>()(a0 , a1);
+        }
+    }
+    template<typename Object , typename A0 , typename A1>
+    struct make<Object(A0 , A1)>
+      : transform<make<Object(A0 , A1)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2>
+          , Expr, State, Data
+            , 3
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2>
+        struct is_applyable<R(A0 , A1 , A2)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2>
+        struct is_applyable<R(*)(A0 , A1 , A2)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 3>, true>
+        {
+            typedef proto::expr<T, A, 3> result_type;
+            template<typename A0 , typename A1 , typename A2>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+            {
+                return result_type::make(a0 , a1 , a2);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 3>, true>
+        {
+            typedef proto::basic_expr<T, A, 3> result_type;
+            template<typename A0 , typename A1 , typename A2>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+            {
+                return result_type::make(a0 , a1 , a2);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2)
+        {
+            return construct_<Type>()(a0 , a1 , a2);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct make<Object(A0 , A1 , A2)>
+      : transform<make<Object(A0 , A1 , A2)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3>
+          , Expr, State, Data
+            , 4
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
+        struct is_applyable<R(A0 , A1 , A2 , A3)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 4>, true>
+        {
+            typedef proto::expr<T, A, 4> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 4>, true>
+        {
+            typedef proto::basic_expr<T, A, 4> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make<Object(A0 , A1 , A2 , A3)>
+      : transform<make<Object(A0 , A1 , A2 , A3)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4>
+          , Expr, State, Data
+            , 5
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 5>, true>
+        {
+            typedef proto::expr<T, A, 5> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 5>, true>
+        {
+            typedef proto::basic_expr<T, A, 5> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make<Object(A0 , A1 , A2 , A3 , A4)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4 , A5>
+          , Expr, State, Data
+            , 6
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 6>, true>
+        {
+            typedef proto::expr<T, A, 6> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 6>, true>
+        {
+            typedef proto::basic_expr<T, A, 6> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4 , A5 , A6>
+          , Expr, State, Data
+            , 7
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 7>, true>
+        {
+            typedef proto::expr<T, A, 7> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 7>, true>
+        {
+            typedef proto::basic_expr<T, A, 7> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+          , Expr, State, Data
+            , 8
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 8>, true>
+        {
+            typedef proto::expr<T, A, 8> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 8>, true>
+        {
+            typedef proto::basic_expr<T, A, 8> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+          , Expr, State, Data
+            , 9
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 9>, true>
+        {
+            typedef proto::expr<T, A, 9> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 9>, true>
+        {
+            typedef proto::basic_expr<T, A, 9> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    namespace detail
+    {
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+          , Expr, State, Data
+            , 10
+        >
+          : nested_type_if<
+                R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type>
+              , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false)
+            >
+        {};
+        template<
+            template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+          , typename Expr, typename State, typename Data
+        >
+        struct make_<
+            noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
+          , Expr, State, Data
+            , 1
+        >
+        {
+            typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type;
+            static bool const applied = true;
+        };
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+          : mpl::true_
+        {};
+        template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+          : mpl::true_
+        {};
+        template<typename T, typename A>
+        struct construct_<proto::expr<T, A, 10>, true>
+        {
+            typedef proto::expr<T, A, 10> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+            }
+        };
+        template<typename T, typename A>
+        struct construct_<proto::basic_expr<T, A, 10>, true>
+        {
+            typedef proto::basic_expr<T, A, 10> result_type;
+            template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+            inline __attribute__ ((always_inline))
+            result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+            {
+                return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+            }
+        };
+        template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        inline __attribute__ ((always_inline))
+        Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9)
+        {
+            return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+    }
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                proto::detail::ignore_unused(e);
+                proto::detail::ignore_unused(s);
+                proto::detail::ignore_unused(d);
+                return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ));
+            }
+        };
+    };
+    template<typename Object>
+    struct is_callable<make<Object> >
+      : mpl::true_
+    {};
+    template<typename PrimitiveTransform>
+    struct is_callable<protect<PrimitiveTransform> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    template<typename Grammar, typename PrimitiveTransform >
+    struct when
+      : PrimitiveTransform
+    {
+        typedef Grammar first;
+        typedef PrimitiveTransform second;
+        typedef typename Grammar::proto_grammar proto_grammar;
+    };
+    template<typename Grammar, typename Fun>
+    struct when<Grammar, Fun *>
+      : when<Grammar, Fun>
+    {};
+    template<typename Fun>
+    struct otherwise
+      : when<_, Fun>
+    {};
+    template<typename Grammar>
+    struct when<Grammar, external_transform>
+      : proto::transform<when<Grammar, external_transform> >
+    {
+        typedef Grammar first;
+        typedef external_transform second;
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : Data::template when<Grammar>::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl<Expr, State, Data &>
+          : Data::template when<Grammar>::template impl<Expr, State, Data &>
+        {};
+    };
+    template< typename T0 = mpl::na , typename T1 = mpl::na , typename T2 = mpl::na , typename T3 = mpl::na , typename T4 = mpl::na , typename T5 = mpl::na , typename T6 = mpl::na , typename T7 = mpl::na , typename T8 = mpl::na , typename T9 = mpl::na , typename T10 = mpl::na , typename T11 = mpl::na , typename T12 = mpl::na , typename T13 = mpl::na , typename T14 = mpl::na , typename T15 = mpl::na , typename T16 = mpl::na , typename T17 = mpl::na , typename T18 = mpl::na , typename T19 = mpl::na >
+    struct external_transforms
+    {
+        typedef mpl::map< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> map_type;
+        template<typename Rule>
+        struct when
+          : proto::when<_, typename mpl::at<map_type, Rule>::type>
+        {};
+    };
+    template<typename Grammar, typename R >
+    struct when<Grammar, R()>
+      : transform<when<Grammar, R()> >
+    {
+        typedef Grammar first;
+        typedef R second();
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R()>
+                  , make<R()>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0>
+    struct when<Grammar, R(A0)>
+      : transform<when<Grammar, R(A0)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0)>
+                  , make<R(A0)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1>
+    struct when<Grammar, R(A0 , A1)>
+      : transform<when<Grammar, R(A0 , A1)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1)>
+                  , make<R(A0 , A1)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2>
+    struct when<Grammar, R(A0 , A1 , A2)>
+      : transform<when<Grammar, R(A0 , A1 , A2)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2)>
+                  , make<R(A0 , A1 , A2)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3>
+    struct when<Grammar, R(A0 , A1 , A2 , A3)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3)>
+                  , make<R(A0 , A1 , A2 , A3)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4)>
+                  , make<R(A0 , A1 , A2 , A3 , A4)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4 , A5);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4 , A5)>
+                  , make<R(A0 , A1 , A2 , A3 , A4 , A5)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : transform<when<Grammar, R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+    {
+        typedef Grammar first;
+        typedef R second(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9);
+        typedef typename Grammar::proto_grammar proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_callable<R>::value
+                  , call<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+                  , make<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            inline __attribute__ ((always_inline))
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template<typename Grammar, typename Transform>
+    struct is_callable<when<Grammar, Transform> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr, typename BasicExpr, typename Grammar>
+        struct matches_;
+        template<bool B, typename Pred>
+        struct and_2;
+        template<typename And, typename Expr, typename State, typename Data>
+        struct _and_impl;
+        template<typename T, typename U>
+        struct array_matches
+          : mpl::false_
+        {};
+        template<typename T, std::size_t M>
+        struct array_matches<T[M], T *>
+          : mpl::true_
+        {};
+        template<typename T, std::size_t M>
+        struct array_matches<T[M], T const *>
+          : mpl::true_
+        {};
+        template<typename T, std::size_t M>
+        struct array_matches<T[M], T[proto::N]>
+          : mpl::true_
+        {};
+        template<typename T, typename U
+            , long Arity = detail::template_arity<U>::value
+        >
+        struct lambda_matches
+          : mpl::false_
+        {};
+        template<typename T>
+        struct lambda_matches<T, proto::_ , -1>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct lambda_matches<T, T , -1>
+          : mpl::true_
+        {};
+        template<typename T, std::size_t M, typename U>
+        struct lambda_matches<T[M], U , -1>
+          : array_matches<T[M], U>
+        {};
+        template<typename T, std::size_t M>
+        struct lambda_matches<T[M], _ , -1>
+          : mpl::true_
+        {};
+        template<typename T, std::size_t M>
+        struct lambda_matches<T[M], T[M] , -1>
+          : mpl::true_
+        {};
+        template<template<typename> class T, typename Expr0, typename Grammar0>
+        struct lambda_matches<T<Expr0>, T<Grammar0> , 1 >
+          : lambda_matches<Expr0, Grammar0>
+        {};
+        template<typename Args1, typename Back, long From, long To>
+        struct vararg_matches_impl;
+        template<typename Expr, typename Args1, typename Args2, typename Back, bool Can, bool Zero, typename Void = void>
+        struct vararg_matches
+          : mpl::false_
+        {};
+        template<typename Expr, typename Args1, typename Args2, typename Back>
+        struct vararg_matches<Expr, Args1, Args2, Back, true, true, typename Back::proto_is_vararg_>
+          : matches_<
+                Expr
+              , proto::basic_expr<ignore, Args1, Args1::arity>
+              , proto::basic_expr<ignore, Args2, Args1::arity>
+            >
+        {};
+        template<typename Expr, typename Args1, typename Args2, typename Back>
+        struct vararg_matches<Expr, Args1, Args2, Back, true, false, typename Back::proto_is_vararg_>
+          : and_2<
+                matches_<
+                    Expr
+                  , proto::basic_expr<ignore, Args1, Args2::arity>
+                  , proto::basic_expr<ignore, Args2, Args2::arity>
+                >::value
+              , vararg_matches_impl<Args1, typename Back::proto_grammar, Args2::arity + 1, Args1::arity>
+            >
+        {};
+        template<typename T, typename U>
+        struct is_cv_ref_compatible
+          : mpl::true_
+        {};
+        template<typename T, typename U>
+        struct is_cv_ref_compatible<T, U &>
+          : mpl::false_
+        {};
+        template<typename T, typename U>
+        struct is_cv_ref_compatible<T &, U &>
+          : mpl::bool_<is_const<T>::value == is_const<U>::value>
+        {};
+        template<typename T, typename U>
+        struct terminal_matches
+          : mpl::and_<
+                is_cv_ref_compatible<T, U>
+              , lambda_matches<
+                    typename boost::proto::detail::uncvref<T>::type
+                  , typename boost::proto::detail::uncvref<U>::type
+                >
+            >
+        {};
+        template<typename T, std::size_t M>
+        struct terminal_matches<T(&)[M], T(&)[proto::N]>
+          : mpl::true_
+        {};
+        template<typename T, std::size_t M>
+        struct terminal_matches<T(&)[M], T *>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct terminal_matches<T, T>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct terminal_matches<T &, T>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct terminal_matches<T const &, T>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct terminal_matches<T, proto::_>
+          : mpl::true_
+        {};
+        template<typename T>
+        struct terminal_matches<T, exact<T> >
+          : mpl::true_
+        {};
+        template<typename T, typename U>
+        struct terminal_matches<T, proto::convertible_to<U> >
+          : is_convertible<T, U>
+        {};
+        template<typename Expr, typename BasicExpr, typename Grammar>
+        struct matches_
+          : mpl::false_
+        {};
+        template<typename Expr, typename BasicExpr>
+        struct matches_< Expr, BasicExpr, proto::_ >
+          : mpl::true_
+        {};
+        template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<Tag, Args2, N2> >
+          : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
+        {};
+        template<typename Expr, typename Tag, typename Args1, long N1, typename Args2, long N2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, N1>, proto::basic_expr<proto::_, Args2, N2> >
+          : vararg_matches< Expr, Args1, Args2, typename Args2::back_, (N1+2 > N2), (N2 > N1) >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<Tag, Args2, 0> >
+          : terminal_matches<typename Args1::child0, typename Args2::child0>
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2, long N2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, N2> >
+          : mpl::false_
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 0>, proto::basic_expr<proto::_, Args2, 0> >
+          : terminal_matches<typename Args1::child0, typename Args2::child0>
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<Tag, Args2, 1> >
+          : matches_<
+                typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
+              , typename Args2::child0::proto_grammar
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 1>, proto::basic_expr<proto::_, Args2, 1> >
+          : matches_<
+                typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar
+              , typename Args2::child0::proto_grammar
+            >
+        {};
+    template<bool B, typename P0>
+    struct and_2
+      : mpl::bool_<P0::value>
+    {};
+    template<typename P0>
+    struct and_2<false, P0>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
+            typedef typename Gimpl1::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d);
+                return Gimpl1()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1>
+    struct and_3
+      : and_2<
+            P0::value ,
+            P1
+        >
+    {};
+    template<typename P0 , typename P1>
+    struct and_3<false, P0 , P1>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2;
+            typedef typename Gimpl2::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d);
+                return Gimpl2()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2>
+    struct and_4
+      : and_3<
+            P0::value ,
+            P1 , P2
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2>
+    struct and_4<false, P0 , P1 , P2>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3;
+            typedef typename Gimpl3::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
+                return Gimpl3()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
+    struct and_5
+      : and_4<
+            P0::value ,
+            P1 , P2 , P3
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3>
+    struct and_5<false, P0 , P1 , P2 , P3>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4;
+            typedef typename Gimpl4::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
+                return Gimpl4()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
+    struct and_6
+      : and_5<
+            P0::value ,
+            P1 , P2 , P3 , P4
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
+    struct and_6<false, P0 , P1 , P2 , P3 , P4>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5;
+            typedef typename Gimpl5::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
+                return Gimpl5()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
+    struct and_7
+      : and_6<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
+    struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6;
+            typedef typename Gimpl6::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
+                return Gimpl6()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
+    struct and_8
+      : and_7<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
+    struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7;
+            typedef typename Gimpl7::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d);
+                return Gimpl7()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+    struct and_9
+      : and_8<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6 , P7
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+    struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
+            typedef typename Gimpl8::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
+                return Gimpl8()(e,s,d);
+            }
+        };
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+    struct and_10
+      : and_9<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+    struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
+            typedef typename Gimpl9::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
+                return Gimpl9()(e,s,d);
+            }
+        };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1>
+    struct or_2
+      : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value>
+    {
+        typedef G1 which;
+    };
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1>
+    struct or_2<true, Expr, BasicExpr, G0 , G1>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
+    struct or_3
+      : or_2<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
+    struct or_3<true, Expr, BasicExpr, G0 , G1 , G2>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
+    struct or_4
+      : or_3<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
+    struct or_4<true, Expr, BasicExpr, G0 , G1 , G2 , G3>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+    struct or_5
+      : or_4<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+    struct or_5<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+    struct or_6
+      : or_5<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+    struct or_6<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+    struct or_7
+      : or_6<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+    struct or_7<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+    struct or_8
+      : or_7<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+    struct or_8<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+    struct or_9
+      : or_8<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+    struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct or_10
+      : or_9<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1> >
+          : or_2<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1> >
+          : detail::and_2<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<Tag, Args2, 2> >
+          : and_2<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<proto::_, Args2, 2> >
+          : and_2<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2> >
+          : or_3<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2> >
+          : detail::and_3<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<Tag, Args2, 3> >
+          : and_3<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<proto::_, Args2, 3> >
+          : and_3<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3> >
+          : or_4<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3> >
+          : detail::and_4<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<Tag, Args2, 4> >
+          : and_4<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<proto::_, Args2, 4> >
+          : and_4<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4> >
+          : or_5<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4> >
+          : detail::and_5<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<Tag, Args2, 5> >
+          : and_5<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<proto::_, Args2, 5> >
+          : and_5<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5> >
+          : or_6<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5> >
+          : detail::and_6<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> >
+          : and_6<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> >
+          : and_6<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
+          : or_7<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
+          : detail::and_7<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> >
+          : and_7<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> >
+          : and_7<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
+          : or_8<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
+          : detail::and_8<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> >
+          : and_8<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> >
+          : and_8<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+          : or_9<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+          : detail::and_9<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> >
+          : and_9<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> >
+          : and_9<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+          : or_10<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+            >
+        {};
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+          : detail::and_10<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> >
+          : and_10<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> >
+          : and_10<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+            >
+        {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 2, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 2 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 2, 2>
+      : matches_<
+            typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 3, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 3 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 3, 3>
+      : matches_<
+            typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 4, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 4 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 4, 4>
+      : matches_<
+            typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 5, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 5 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 5, 5>
+      : matches_<
+            typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 6, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 6 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 6, 6>
+      : matches_<
+            typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 7, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 7 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 7, 7>
+      : matches_<
+            typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 8, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 8 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 8, 8>
+      : matches_<
+            typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 9, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 9 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 9, 9>
+      : matches_<
+            typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 10, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 10 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 10, 10>
+      : matches_<
+            typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<
+        template<typename , typename> class T
+        , typename Expr0 , typename Expr1
+        , typename Grammar0 , typename Grammar1
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1>
+      , T<Grammar0 , Grammar1>
+        , 2
+    >
+      : and_2<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 >
+        >
+    {};
+    template<
+        template<typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2
+        , typename Grammar0 , typename Grammar1 , typename Grammar2
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2>
+      , T<Grammar0 , Grammar1 , Grammar2>
+        , 3
+    >
+      : and_3<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3>
+        , 4
+    >
+      : and_4<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4>
+        , 5
+    >
+      : and_5<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5>
+        , 6
+    >
+      : and_6<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6>
+        , 7
+    >
+      : and_7<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7>
+        , 8
+    >
+      : and_8<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8>
+        , 9
+    >
+      : and_9<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9>
+        , 10
+    >
+      : and_10<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 >
+        >
+    {};
+        template<typename Expr, typename Tag, typename Args, long Arity, typename If, typename Then, typename Else>
+        struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, proto::if_<If, Then, Else> >
+          : mpl::eval_if_c<
+                remove_reference<
+                    typename when<_, If>::template impl<Expr, int, int>::result_type
+                >::type::value
+              , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Then::proto_grammar>
+              , matches_<Expr, proto::basic_expr<Tag, Args, Arity>, typename Else::proto_grammar>
+            >::type
+        {
+            typedef
+                typename mpl::if_c<
+                    remove_reference<
+                        typename when<_, If>::template impl<Expr, int, int>::result_type
+                    >::type::value
+                  , Then
+                  , Else
+                >::type
+            which;
+        };
+        template<typename Expr, typename BasicExpr>
+        struct matches_<Expr, BasicExpr, or_<> >
+          : mpl::false_
+        {
+            typedef not_<_> which;
+        };
+        template<typename Expr, typename BasicExpr, typename G0>
+        struct matches_<Expr, BasicExpr, or_<G0> >
+          : matches_<Expr, BasicExpr, typename G0::proto_grammar>
+        {
+            typedef G0 which;
+        };
+        template<typename Expr, typename BasicExpr>
+        struct matches_<Expr, BasicExpr, and_<> >
+          : mpl::true_
+        {};
+        template<typename Expr, typename BasicExpr, typename G0>
+        struct matches_<Expr, BasicExpr, and_<G0> >
+          : matches_<Expr, BasicExpr, typename G0::proto_grammar>
+        {};
+        template<typename Expr, typename BasicExpr, typename Grammar>
+        struct matches_<Expr, BasicExpr, not_<Grammar> >
+          : mpl::not_<matches_<Expr, BasicExpr, typename Grammar::proto_grammar> >
+        {};
+        template<typename Expr, typename Tag, typename Args, long Arity, typename Cases, typename Transform>
+        struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases, Transform> >
+          : matches_<
+                Expr
+              , proto::basic_expr<Tag, Args, Arity>
+              , typename Cases::template case_<
+                    typename when<_,Transform>::template impl<Expr,int,int>::result_type
+                >::proto_grammar
+            >
+        {
+            typedef
+                typename Cases::template case_<
+                    typename when<_, Transform>::template impl<Expr, int, int>::result_type
+                >
+            which;
+        };
+        template<typename Expr, typename Tag, typename Args, long Arity, typename Cases>
+        struct matches_<Expr, proto::basic_expr<Tag, Args, Arity>, switch_<Cases> >
+          : matches_<
+                Expr
+              , proto::basic_expr<Tag, Args, Arity>
+              , typename Cases::template case_<Tag>::proto_grammar
+            >
+        {
+            typedef typename Cases::template case_<Tag> which;
+        };
+    }
+    template<typename Expr, typename Grammar>
+    struct matches
+      : detail::matches_<
+            typename Expr::proto_derived_expr
+          , typename Expr::proto_grammar
+          , typename Grammar::proto_grammar
+        >
+    {};
+    template<typename Expr, typename Grammar>
+    struct matches<Expr &, Grammar>
+      : detail::matches_<
+            typename Expr::proto_derived_expr
+          , typename Expr::proto_grammar
+          , typename Grammar::proto_grammar
+        >
+    {};
+    struct _ : transform<_>
+    {
+        typedef _ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            typename impl::expr_param
+            operator()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+    };
+    namespace detail
+    {
+        template<typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<>, Expr, State, Data>
+          : proto::_::impl<Expr, State, Data>
+        {};
+        template<typename G0, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0>, Expr, State, Data>
+          : proto::when<proto::_, G0>::template impl<Expr, State, Data>
+        {};
+    }
+    template<typename Grammar>
+    struct not_ : transform<not_<Grammar> >
+    {
+        typedef not_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            typename impl::expr_param
+            operator()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+    };
+    template<
+        typename If
+      , typename Then
+      , typename Else
+    >
+    struct if_ : transform<if_<If, Then, Else> >
+    {
+        typedef if_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename when<_, If>::template impl<Expr, State, Data>::result_type
+            condition;
+            typedef
+                typename mpl::if_c<
+                    remove_reference<condition>::type::value
+                  , when<_, Then>
+                  , when<_, Else>
+                >::type
+            which;
+            typedef typename which::template impl<Expr, State, Data>::result_type result_type;
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                return typename which::template impl<Expr, State, Data>()(e, s, d);
+            }
+        };
+    };
+    template< typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct or_ : transform<or_< G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+    {
+        typedef or_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::matches_<
+                typename Expr::proto_derived_expr
+              , typename Expr::proto_grammar
+              , or_
+            >::which::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl<Expr &, State, Data>
+          : detail::matches_<
+                typename Expr::proto_derived_expr
+              , typename Expr::proto_grammar
+              , or_
+            >::which::template impl<Expr &, State, Data>
+        {};
+    };
+    template< typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct and_ : transform<and_< G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+    {
+        typedef and_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::_and_impl<and_, Expr, State, Data>
+        {};
+    };
+    template<typename Cases, typename Transform>
+    struct switch_ : transform<switch_<Cases, Transform> >
+    {
+        typedef switch_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : Cases::template case_<
+                typename when<_, Transform>::template impl<Expr, State, Data>::result_type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Cases>
+    struct switch_<Cases> : transform<switch_<Cases> >
+    {
+        typedef switch_ proto_grammar;
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : Cases::template case_<typename Expr::proto_tag>::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl<Expr &, State, Data>
+          : Cases::template case_<typename Expr::proto_tag>::template impl<Expr &, State, Data>
+        {};
+    };
+    template<typename T>
+    struct exact
+    {};
+    template<typename T>
+    struct convertible_to
+    {};
+    template<typename Grammar>
+    struct vararg
+      : Grammar
+    {
+        typedef void proto_is_vararg_;
+    };
+    template< typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct is_callable<or_< G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+      : mpl::true_
+    {};
+    template< typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct is_callable<and_< G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+      : mpl::true_
+    {};
+    template<typename Grammar>
+    struct is_callable<not_<Grammar> >
+      : mpl::true_
+    {};
+    template<typename If, typename Then, typename Else>
+    struct is_callable<if_<If, Then, Else> >
+      : mpl::true_
+    {};
+    template<typename Grammar>
+    struct is_callable<vararg<Grammar> >
+      : mpl::true_
+    {};
+    template<typename Cases, typename Transform>
+    struct is_callable<switch_<Cases, Transform> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace exprns_
+    {
+        struct is_proto_expr
+        {};
+        template<
+            typename Expr
+          , typename Derived
+          , typename Domain
+          , long Arity
+        >
+        struct extends
+        {
+            inline __attribute__ ((always_inline))
+            extends()
+              : proto_expr_()
+            {}
+            inline __attribute__ ((always_inline))
+            extends(extends const &that)
+              : proto_expr_(that.proto_expr_)
+            {}
+            inline __attribute__ ((always_inline))
+            extends(Expr const &expr_)
+              : proto_expr_(expr_)
+            {}
+            typedef extends proto_extends;
+            Expr proto_expr_; typedef Expr proto_base_expr_; typedef typename proto_base_expr_::proto_base_expr proto_base_expr; typedef Domain proto_domain; typedef Derived proto_derived_expr; typedef typename Domain::proto_generator proto_generator; typedef typename proto_base_expr::proto_tag proto_tag; typedef typename proto_base_expr::proto_args proto_args; typedef typename proto_base_expr::proto_arity proto_arity; typedef typename proto_base_expr::proto_grammar proto_grammar; typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; typedef void proto_is_expr_; static const long proto_arity_c = proto_base_expr::proto_arity_c; typedef boost::proto::tag::proto_expr fusion_tag; typedef typename proto_base_expr::proto_child0 proto_child0; typedef typename proto_base_expr::proto_child1 proto_child1; typedef typename proto_base_expr::proto_child2 proto_child2; typedef typename proto_base_expr::proto_child3 proto_child3; typedef typename proto_base_expr::proto_child4 proto_child4; typedef typename proto_base_expr::proto_child5 proto_child5; typedef typename proto_base_expr::proto_child6 proto_child6; typedef typename proto_base_expr::proto_child7 proto_child7; typedef typename proto_base_expr::proto_child8 proto_child8; typedef typename proto_base_expr::proto_child9 proto_child9; inline __attribute__ ((always_inline)) static proto_derived_expr const make(Expr const &e) { proto_derived_expr that = {e}; return that; } inline __attribute__ ((always_inline)) proto_base_expr &proto_base() { return this->proto_expr_.proto_base(); } inline __attribute__ ((always_inline)) proto_base_expr const &proto_base() const { return this->proto_expr_.proto_base(); } inline __attribute__ ((always_inline)) operator proto_address_of_hack_type_() const { return boost::addressof(this->proto_base().child0); }
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator =(A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator =(A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator [](A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator [](A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+    template<typename Sig> struct result { typedef typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
+        inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); }
+        template<typename A0> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); }
+        template<typename A0 , typename A1> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); }
+        template<typename A0 , typename A1 , typename A2> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }
+        };
+        template<typename Expr, typename Derived, typename Domain>
+        struct extends<Expr, Derived, Domain, 0>
+        {
+            inline __attribute__ ((always_inline))
+            extends()
+              : proto_expr_()
+            {}
+            inline __attribute__ ((always_inline))
+            extends(extends const &that)
+              : proto_expr_(that.proto_expr_)
+            {}
+            inline __attribute__ ((always_inline))
+            extends(Expr const &expr_)
+              : proto_expr_(expr_)
+            {}
+            typedef extends proto_extends;
+            Expr proto_expr_; typedef Expr proto_base_expr_; typedef typename proto_base_expr_::proto_base_expr proto_base_expr; typedef Domain proto_domain; typedef Derived proto_derived_expr; typedef typename Domain::proto_generator proto_generator; typedef typename proto_base_expr::proto_tag proto_tag; typedef typename proto_base_expr::proto_args proto_args; typedef typename proto_base_expr::proto_arity proto_arity; typedef typename proto_base_expr::proto_grammar proto_grammar; typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; typedef void proto_is_expr_; static const long proto_arity_c = proto_base_expr::proto_arity_c; typedef boost::proto::tag::proto_expr fusion_tag; typedef typename proto_base_expr::proto_child0 proto_child0; typedef typename proto_base_expr::proto_child1 proto_child1; typedef typename proto_base_expr::proto_child2 proto_child2; typedef typename proto_base_expr::proto_child3 proto_child3; typedef typename proto_base_expr::proto_child4 proto_child4; typedef typename proto_base_expr::proto_child5 proto_child5; typedef typename proto_base_expr::proto_child6 proto_child6; typedef typename proto_base_expr::proto_child7 proto_child7; typedef typename proto_base_expr::proto_child8 proto_child8; typedef typename proto_base_expr::proto_child9 proto_child9; inline __attribute__ ((always_inline)) static proto_derived_expr const make(Expr const &e) { proto_derived_expr that = {e}; return that; } inline __attribute__ ((always_inline)) proto_base_expr &proto_base() { return this->proto_expr_.proto_base(); } inline __attribute__ ((always_inline)) proto_base_expr const &proto_base() const { return this->proto_expr_.proto_base(); } inline __attribute__ ((always_inline)) operator proto_address_of_hack_type_() const { return boost::addressof(this->proto_base().child0); }
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator =(A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator =(A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator =(A &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator =(A const &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator [](A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator [](A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator [](A &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator [](A const &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+    template<typename Sig> struct result { typedef typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
+        inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); }
+        template<typename A0> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); }
+        template<typename A0 , typename A1> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); }
+        template<typename A0 , typename A1 , typename A2> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }
+        };
+        template<typename This, typename Fun, typename Domain>
+        struct virtual_member
+        {
+            typedef Domain proto_domain;
+            typedef typename Domain::proto_generator proto_generator;
+            typedef virtual_member<This, Fun, Domain> proto_derived_expr;
+            typedef tag::member proto_tag;
+            typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
+            typedef mpl::long_<2> proto_arity;
+            typedef detail::not_a_valid_type proto_address_of_hack_type_;
+            typedef void proto_is_expr_;
+            static const long proto_arity_c = 2;
+            typedef boost::proto::tag::proto_expr fusion_tag;
+            typedef This &proto_child0;
+            typedef expr<tag::terminal, term<Fun> > const &proto_child1;
+            typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
+            typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
+            typedef void proto_is_aggregate_;
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator =(A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator =(A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator =(A &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator =(A const &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::assign , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+            template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator [](A &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator [](A const &a) const { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr const & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr const *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type ) >::type const operator [](A &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A , proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); } template<typename A> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type ) >::type const operator [](A const &a) { typedef typename boost::proto::base_expr< proto_domain , boost::proto::tag::subscript , boost::proto::list2< proto_derived_expr & , typename boost::proto::result_of::as_child<A const, proto_domain>::type > >::type that_type; that_type const that = { *static_cast<proto_derived_expr *>(this) , boost::proto::as_child<proto_domain>(a) }; return proto_generator()(that); }
+    template<typename Sig> struct result { typedef typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
+        inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); }
+        template<typename A0> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); }
+        template<typename A0 , typename A1> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); }
+        template<typename A0 , typename A1 , typename A2> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline __attribute__ ((always_inline)) typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }
+            inline __attribute__ ((always_inline))
+            proto_base_expr const proto_base() const
+            {
+                proto_base_expr that = {this->child0(), this->child1()};
+                return that;
+            }
+            inline __attribute__ ((always_inline))
+            proto_child0 child0() const
+            {
+                using std::size_t;
+                return *(This *)((char *)this - (((char const volatile*)boost::addressof((((This *)this)->proto_member_union_start_))) - ((char const volatile*)boost::addressof(*((This *)this)))));
+            }
+            inline __attribute__ ((always_inline))
+            proto_child1 child1() const
+            {
+                static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
+                return that;
+            }
+        };
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace utility
+    {
+        template<
+            typename T
+          , typename Domain
+        >
+        struct literal
+          : extends<basic_expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain>
+        {
+        private:
+            typedef basic_expr<tag::terminal, term<T>, 0> terminal_type;
+            typedef extends<terminal_type, literal<T, Domain>, Domain> base_type;
+            typedef literal<T, Domain> literal_t;
+        public:
+            typedef typename detail::term_traits<T>::value_type value_type;
+            typedef typename detail::term_traits<T>::reference reference;
+            typedef typename detail::term_traits<T>::const_reference const_reference;
+            literal()
+              : base_type(terminal_type::make(T()))
+            {}
+            template<typename U>
+            literal(U &u)
+              : base_type(terminal_type::make(u))
+            {}
+            template<typename U>
+            literal(U const &u)
+              : base_type(terminal_type::make(u))
+            {}
+            template<typename U>
+            literal(literal<U, Domain> const &u)
+              : base_type(terminal_type::make(u.get()))
+            {}
+            typedef typename literal_t::proto_extends proto_extends; using proto_extends::operator =; inline __attribute__ ((always_inline)) typename boost::tr1_result_of< typename literal_t::proto_generator( typename boost::proto::base_expr< typename literal_t::proto_domain , boost::proto::tag::assign , boost::proto::list2< literal_t & , literal_t const & > >::type ) >::type const operator =(literal_t const &a) { typedef typename boost::proto::base_expr< typename literal_t::proto_domain , boost::proto::tag::assign , boost::proto::list2< literal_t & , literal_t const & > >::type that_type; that_type const that = { *this , a }; return typename literal_t::proto_generator()(that); }
+            reference get()
+            {
+                return proto::value(*this);
+            }
+            const_reference get() const
+            {
+                return proto::value(*this);
+            }
+        };
+    }
+    template<typename T>
+    inline literal<T &> const lit(T &t)
+    {
+        return literal<T &>(t);
+    }
+    template<typename T>
+    inline literal<T const &> const lit(T const &t)
+    {
+        return literal<T const &>(t);
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T, typename Domain>
+        struct protoify
+          : Domain::template as_expr<T>
+        {};
+        template<typename T, typename Domain>
+        struct protoify<T &, Domain>
+          : Domain::template as_child<T>
+        {};
+        template<typename T, typename Domain>
+        struct protoify<boost::reference_wrapper<T>, Domain>
+          : Domain::template as_child<T>
+        {};
+        template<typename T, typename Domain>
+        struct protoify<boost::reference_wrapper<T> const, Domain>
+          : Domain::template as_child<T>
+        {};
+    template<typename Tag, typename Domain, typename Sequence, std::size_t Size>
+    struct unpack_expr_
+    {};
+    template<typename Domain, typename Sequence>
+    struct unpack_expr_<tag::terminal, Domain, Sequence, 1u>
+    {
+        typedef
+            typename add_const<
+                typename fusion::result_of::value_of<
+                    typename fusion::result_of::begin<Sequence>::type
+                >::type
+            >::type
+        terminal_type;
+        typedef
+            typename proto::detail::protoify<
+                terminal_type
+              , Domain
+            >::result_type
+        type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence));
+        }
+    };
+    template<typename Sequence>
+    struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u>
+      : unpack_expr_<tag::terminal, default_domain, Sequence, 1u>
+    {};
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 1>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
+        typedef
+            list1<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 1>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain1<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type
+                >::type
+              , Sequence
+              , 1
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 2>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
+        typedef
+            list2<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 2>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain2<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type
+                >::type
+              , Sequence
+              , 2
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 3>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
+        typedef
+            list3<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 3>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain3<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type
+                >::type
+              , Sequence
+              , 3
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 4>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
+        typedef
+            list4<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 4>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain4<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type
+                >::type
+              , Sequence
+              , 4
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 5>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
+        typedef
+            list5<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 5>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain5<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type
+                >::type
+              , Sequence
+              , 5
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 6>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+        typedef
+            list6<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 6>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain6<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type
+                >::type
+              , Sequence
+              , 6
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 7>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+        typedef
+            list7<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 7>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain7<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type
+                >::type
+              , Sequence
+              , 7
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 8>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+        typedef
+            list8<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 8>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain8<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type
+                >::type
+              , Sequence
+              , 8
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 9>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+        typedef
+            list9<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 9>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain9<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type
+                >::type
+              , Sequence
+              , 9
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 10>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+        typedef
+            list10<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 10>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain10<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type
+                >::type
+              , Sequence
+              , 10
+            >
+        other;
+        typedef typename other::type type;
+        inline __attribute__ ((always_inline))
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<
+        typename Tag
+      , typename Domain
+        , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
+      , typename _ = void
+    >
+    struct make_expr_
+    {};
+    template<typename Domain, typename A>
+    struct make_expr_<tag::terminal, Domain, A
+        , void , void , void , void , void , void , void , void , void , void>
+    {
+        typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A>::type a) const
+        {
+            return proto::detail::protoify<A, Domain>()(a);
+        }
+    };
+    template<typename A>
+    struct make_expr_<tag::terminal, deduce_domain, A
+        , void , void , void , void , void , void , void , void , void , void>
+      : make_expr_<tag::terminal, default_domain, A>
+    {};
+    template<typename Tag, typename Domain , typename A0>
+    struct make_expr_<Tag, Domain , A0
+        , void , void , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list1<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0>
+    struct make_expr_<Tag, deduce_domain , A0
+        , void , void , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain1<A0>::type
+            , A0
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1>
+    struct make_expr_<Tag, Domain , A0 , A1
+        , void , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list2<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1>
+    struct make_expr_<Tag, deduce_domain , A0 , A1
+        , void , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain2<A0 , A1>::type
+            , A0 , A1
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2
+        , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list3<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2
+        , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain3<A0 , A1 , A2>::type
+            , A0 , A1 , A2
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3
+        , void , void , void , void , void , void, void>
+    {
+        typedef
+            list4<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3
+        , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain4<A0 , A1 , A2 , A3>::type
+            , A0 , A1 , A2 , A3
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4
+        , void , void , void , void , void, void>
+    {
+        typedef
+            list5<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4
+        , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type
+            , A0 , A1 , A2 , A3 , A4
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5
+        , void , void , void , void, void>
+    {
+        typedef
+            list6<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5
+        , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type
+            , A0 , A1 , A2 , A3 , A4 , A5
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        , void , void , void, void>
+    {
+        typedef
+            list7<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        , void , void, void>
+    {
+        typedef
+            list8<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        , void, void>
+    {
+        typedef
+            list9<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        , void>
+    {
+        typedef
+            list10<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        inline __attribute__ ((always_inline))
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        , void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        >
+    {};
+    }
+    namespace result_of
+    {
+        template<
+            typename Tag
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+          , typename Void1
+          , typename Void2
+        >
+        struct make_expr
+        {
+            typedef
+                typename detail::make_expr_<
+                    Tag
+                  , deduce_domain
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+                >::result_type
+            type;
+        };
+        template<
+            typename Tag
+          , typename Domain
+            , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+        >
+        struct make_expr<
+            Tag
+          , Domain
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+          , typename Domain::proto_is_domain_
+        >
+        {
+            typedef
+                typename detail::make_expr_<
+                    Tag
+                  , Domain
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+                >::result_type
+            type;
+        };
+        template<
+            typename Tag
+          , typename Sequence
+          , typename Void1
+          , typename Void2
+        >
+        struct unpack_expr
+        {
+            typedef
+                typename detail::unpack_expr_<
+                    Tag
+                  , deduce_domain
+                  , Sequence
+                  , fusion::result_of::size<Sequence>::type::value
+                >::type
+            type;
+        };
+        template<typename Tag, typename Domain, typename Sequence>
+        struct unpack_expr<Tag, Domain, Sequence, typename Domain::proto_is_domain_>
+        {
+            typedef
+                typename detail::unpack_expr_<
+                    Tag
+                  , Domain
+                  , Sequence
+                  , fusion::result_of::size<Sequence>::type::value
+                >::type
+            type;
+        };
+    }
+    namespace functional
+    {
+        template<typename Tag, typename Domain >
+        struct make_expr
+        {
+            typedef void proto_is_callable_;
+            typedef void is_poly_function_base_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename A0>
+            struct result<This(A0)>
+            {
+                typedef
+                    typename result_of::make_expr<
+                        Tag
+                      , Domain
+                      , A0
+                    >::type
+                type;
+            };
+            template<typename A0>
+            inline __attribute__ ((always_inline))
+            typename result_of::make_expr<
+                Tag
+              , Domain
+              , A0 const
+            >::type const
+            operator ()(A0 const &a0) const
+            {
+                return proto::detail::make_expr_<
+                    Tag
+                  , Domain
+                  , A0 const
+                >()(a0);
+            }
+    template<typename This , typename A0 , typename A1>
+    struct result<This(A0 , A1)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1
+        >()(a0 , a1);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2>
+    struct result<This(A0 , A1 , A2)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2
+        >()(a0 , a1 , a2);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
+    struct result<This(A0 , A1 , A2 , A3)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3
+        >()(a0 , a1 , a2 , a3);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct result<This(A0 , A1 , A2 , A3 , A4)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >()(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >()(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+    >::type const
+    operator ()(const A0 &a0 , 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 proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+            >::type
+        type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+    >::type const
+    operator ()(const A0 &a0 , 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 proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+            template<
+ typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
+            >
+            struct impl
+              : detail::make_expr_<
+                    Tag
+                  , Domain
+                    , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+                >
+            {};
+        };
+        template<typename Tag, typename Domain >
+        struct unpack_expr
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Sequence>
+            struct result<This(Sequence)>
+            {
+                typedef
+                    typename result_of::unpack_expr<
+                        Tag
+                      , Domain
+                      , typename remove_reference<Sequence>::type
+                    >::type
+                type;
+            };
+            template<typename Sequence>
+            inline __attribute__ ((always_inline))
+            typename result_of::unpack_expr<Tag, Domain, Sequence const>::type const
+            operator ()(Sequence const &sequence) const
+            {
+                return proto::detail::unpack_expr_<
+                    Tag
+                  , Domain
+                  , Sequence const
+                  , fusion::result_of::size<Sequence>::type::value
+                >::call(sequence);
+            }
+        };
+    }
+    template<typename Tag, typename A0>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+          , A0 const
+        >
+    >::type const
+    make_expr(A0 const &a0)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+          , A0 const
+        >()(a0);
+    }
+    template<typename Tag, typename Domain, typename C0>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+      , C0 const
+    >::type const
+    make_expr(C0 const &c0)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+          , C0 const
+        >()(c0);
+    }
+    template<typename Tag , typename A0 , typename A1>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1
+        >()(a0 , a1);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1
+        >()(c0 , c1);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2
+        >()(a0 , a1 , a2);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2
+        >()(c0 , c1 , c2);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3
+        >()(a0 , a1 , a2 , a3);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3
+        >()(c0 , c1 , c2 , c3);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >()(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4
+        >()(c0 , c1 , c2 , c3 , c4);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >()(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+        >()(c0 , c1 , c2 , c3 , c4 , c5);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8);
+    }
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >
+    >::type const
+    make_expr(const A0 &a0 , 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)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9>
+    inline __attribute__ ((always_inline))
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9);
+    }
+    template<typename Tag, typename Sequence>
+    inline __attribute__ ((always_inline))
+    typename lazy_disable_if<
+        is_domain<Sequence>
+      , result_of::unpack_expr<Tag, Sequence const>
+    >::type const
+    unpack_expr(Sequence const &sequence)
+    {
+        return proto::detail::unpack_expr_<
+            Tag
+          , deduce_domain
+          , Sequence const
+          , fusion::result_of::size<Sequence>::type::value
+        >::call(sequence);
+    }
+    template<typename Tag, typename Domain, typename Sequence2>
+    inline __attribute__ ((always_inline))
+    typename result_of::unpack_expr<Tag, Domain, Sequence2 const>::type const
+    unpack_expr(Sequence2 const &sequence2)
+    {
+        return proto::detail::unpack_expr_<
+            Tag
+          , Domain
+          , Sequence2 const
+          , fusion::result_of::size<Sequence2>::type::value
+        >::call(sequence2);
+    }
+    template<typename Tag, typename Domain>
+    struct is_callable<functional::make_expr<Tag, Domain> >
+      : mpl::true_
+    {};
+    template<typename Tag, typename Domain>
+    struct is_callable<functional::unpack_expr<Tag, Domain> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename MakeExpr, typename Grammar>
+        struct lazy_matches
+          : proto::matches<typename MakeExpr::type, Grammar>
+        {};
+        template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Arg>
+        struct enable_unary
+          : boost::lazy_enable_if_c<
+                boost::mpl::and_<
+                    Trait
+                  , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Arg>, Grammar>
+                >::value
+              , result_of::make_expr<Tag, Domain, Arg>
+            >
+        {};
+        template<typename Domain, typename Trait, typename Tag, typename Arg>
+        struct enable_unary<Domain, proto::_, Trait, Tag, Arg &>
+          : boost::lazy_enable_if_c<
+                Trait::value
+              , result_of::make_expr<Tag, Domain, Arg &>
+            >
+        {};
+        template<typename Trait, typename Tag, typename Arg>
+        struct enable_unary<deduce_domain, not_a_grammar, Trait, Tag, Arg &>
+          : enable_unary<
+                typename domain_of<Arg>::type
+              , typename domain_of<Arg>::type::proto_grammar
+              , Trait
+              , Tag
+              , Arg &
+            >
+        {};
+        template<typename Domain, typename Grammar, typename Trait, typename Tag, typename Left, typename Right>
+        struct enable_binary
+          : boost::lazy_enable_if_c<
+                boost::mpl::and_<
+                    Trait
+                  , lazy_matches<result_of::make_expr<Tag, basic_default_domain, Left, Right>, Grammar>
+                >::value
+              , result_of::make_expr<Tag, Domain, Left, Right>
+            >
+        {};
+        template<typename Domain, typename Trait, typename Tag, typename Left, typename Right>
+        struct enable_binary<Domain, proto::_, Trait, Tag, Left &, Right &>
+          : boost::lazy_enable_if_c<
+                Trait::value
+              , result_of::make_expr<Tag, Domain, Left &, Right &>
+            >
+        {};
+        template<typename Trait, typename Tag, typename Left, typename Right>
+        struct enable_binary<deduce_domain, not_a_grammar, Trait, Tag, Left &, Right &>
+          : enable_binary<
+                typename deduce_domain2<Left, Right>::type
+              , typename deduce_domain2<Left, Right>::type::proto_grammar
+              , Trait
+              , Tag
+              , Left &
+              , Right &
+            >
+        {};
+    }
+    template<typename T>
+    struct is_extension
+      : is_expr<T>
+    {};
+    template<typename T>
+    struct is_extension<T &>
+      : is_expr<T>
+    {};
+    namespace exprns_
+    {
+        template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::unary_plus , Arg & >::type const operator +(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::unary_plus , Arg const & >::type const operator +(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::unary_plus, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::negate , Arg & >::type const operator -(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::negate, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::negate , Arg const & >::type const operator -(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::negate, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::dereference , Arg & >::type const operator *(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::dereference, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::dereference , Arg const & >::type const operator *(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::dereference, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::complement , Arg & >::type const operator ~(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::complement, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::complement , Arg const & >::type const operator ~(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::complement, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::address_of , Arg & >::type const operator &(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::address_of, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::address_of , Arg const & >::type const operator &(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::address_of, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::logical_not , Arg & >::type const operator !(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_not, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::logical_not , Arg const & >::type const operator !(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_not, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::pre_inc , Arg & >::type const operator ++(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::pre_inc, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::pre_inc , Arg const & >::type const operator ++(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::pre_inc, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::pre_dec , Arg & >::type const operator --(Arg &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::pre_dec, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::pre_dec , Arg const & >::type const operator --(Arg const &arg ) { return boost::proto::detail::make_expr_<boost::proto::tag::pre_dec, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::post_inc , Arg & >::type const operator ++(Arg &arg , int) { return boost::proto::detail::make_expr_<boost::proto::tag::post_inc, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::post_inc , Arg const & >::type const operator ++(Arg const &arg , int) { return boost::proto::detail::make_expr_<boost::proto::tag::post_inc, deduce_domain, Arg const &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::post_dec , Arg & >::type const operator --(Arg &arg , int) { return boost::proto::detail::make_expr_<boost::proto::tag::post_dec, deduce_domain, Arg &>()(arg); } template<typename Arg> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_unary< deduce_domain , deduce_domain::proto_grammar , is_extension<Arg> , boost::proto::tag::post_dec , Arg const & >::type const operator --(Arg const &arg , int) { return boost::proto::detail::make_expr_<boost::proto::tag::post_dec, deduce_domain, Arg const &>()(arg); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left , Left & , Right & >::type const operator <<(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left , Left & , Right const & >::type const operator <<(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left , Left const & , Right & >::type const operator <<(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left , Left const & , Right const & >::type const operator <<(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right , Left & , Right & >::type const operator >>(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right , Left & , Right const & >::type const operator >>(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right , Left const & , Right & >::type const operator >>(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right , Left const & , Right const & >::type const operator >>(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies , Left & , Right & >::type const operator *(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies , Left & , Right const & >::type const operator *(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies , Left const & , Right & >::type const operator *(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies , Left const & , Right const & >::type const operator *(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides , Left & , Right & >::type const operator /(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides , Left & , Right const & >::type const operator /(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides , Left const & , Right & >::type const operator /(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides , Left const & , Right const & >::type const operator /(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus , Left & , Right & >::type const operator %(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus , Left & , Right const & >::type const operator %(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus , Left const & , Right & >::type const operator %(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus , Left const & , Right const & >::type const operator %(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus , Left & , Right & >::type const operator +(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus , Left & , Right const & >::type const operator +(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus , Left const & , Right & >::type const operator +(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus , Left const & , Right const & >::type const operator +(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus , Left & , Right & >::type const operator -(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus , Left & , Right const & >::type const operator -(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus , Left const & , Right & >::type const operator -(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus , Left const & , Right const & >::type const operator -(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less , Left & , Right & >::type const operator <(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less , Left & , Right const & >::type const operator <(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less , Left const & , Right & >::type const operator <(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less , Left const & , Right const & >::type const operator <(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater , Left & , Right & >::type const operator >(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater , Left & , Right const & >::type const operator >(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater , Left const & , Right & >::type const operator >(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater , Left const & , Right const & >::type const operator >(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less_equal , Left & , Right & >::type const operator <=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less_equal, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less_equal , Left & , Right const & >::type const operator <=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less_equal, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less_equal , Left const & , Right & >::type const operator <=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less_equal, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::less_equal , Left const & , Right const & >::type const operator <=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::less_equal, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater_equal , Left & , Right & >::type const operator >=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater_equal, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater_equal , Left & , Right const & >::type const operator >=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater_equal, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater_equal , Left const & , Right & >::type const operator >=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater_equal, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::greater_equal , Left const & , Right const & >::type const operator >=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::greater_equal, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::equal_to , Left & , Right & >::type const operator ==(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::equal_to, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::equal_to , Left & , Right const & >::type const operator ==(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::equal_to, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::equal_to , Left const & , Right & >::type const operator ==(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::equal_to, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::equal_to , Left const & , Right const & >::type const operator ==(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::equal_to, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::not_equal_to , Left & , Right & >::type const operator !=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::not_equal_to, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::not_equal_to , Left & , Right const & >::type const operator !=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::not_equal_to, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::not_equal_to , Left const & , Right & >::type const operator !=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::not_equal_to, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::not_equal_to , Left const & , Right const & >::type const operator !=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::not_equal_to, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_or , Left & , Right & >::type const operator ||(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_or, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_or , Left & , Right const & >::type const operator ||(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_or, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_or , Left const & , Right & >::type const operator ||(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_or, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_or , Left const & , Right const & >::type const operator ||(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_or, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_and , Left & , Right & >::type const operator &&(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_and, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_and , Left & , Right const & >::type const operator &&(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_and, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_and , Left const & , Right & >::type const operator &&(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_and, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::logical_and , Left const & , Right const & >::type const operator &&(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::logical_and, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and , Left & , Right & >::type const operator &(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and , Left & , Right const & >::type const operator &(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and , Left const & , Right & >::type const operator &(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and , Left const & , Right const & >::type const operator &(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or , Left & , Right & >::type const operator |(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or , Left & , Right const & >::type const operator |(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or , Left const & , Right & >::type const operator |(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or , Left const & , Right const & >::type const operator |(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor , Left & , Right & >::type const operator ^(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor , Left & , Right const & >::type const operator ^(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor , Left const & , Right & >::type const operator ^(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor , Left const & , Right const & >::type const operator ^(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::comma , Left & , Right & >::type const operator ,(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::comma, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::comma , Left & , Right const & >::type const operator ,(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::comma, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::comma , Left const & , Right & >::type const operator ,(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::comma, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::comma , Left const & , Right const & >::type const operator ,(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::comma, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::mem_ptr , Left & , Right & >::type const operator ->*(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::mem_ptr, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::mem_ptr , Left & , Right const & >::type const operator ->*(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::mem_ptr, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::mem_ptr , Left const & , Right & >::type const operator ->*(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::mem_ptr, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::mem_ptr , Left const & , Right const & >::type const operator ->*(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::mem_ptr, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left_assign , Left & , Right & >::type const operator <<=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left_assign , Left & , Right const & >::type const operator <<=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left_assign , Left const & , Right & >::type const operator <<=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_left_assign , Left const & , Right const & >::type const operator <<=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_left_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right_assign , Left & , Right & >::type const operator >>=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right_assign , Left & , Right const & >::type const operator >>=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right_assign , Left const & , Right & >::type const operator >>=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::shift_right_assign , Left const & , Right const & >::type const operator >>=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::shift_right_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies_assign , Left & , Right & >::type const operator *=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies_assign , Left & , Right const & >::type const operator *=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies_assign , Left const & , Right & >::type const operator *=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::multiplies_assign , Left const & , Right const & >::type const operator *=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::multiplies_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides_assign , Left & , Right & >::type const operator /=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides_assign , Left & , Right const & >::type const operator /=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides_assign , Left const & , Right & >::type const operator /=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::divides_assign , Left const & , Right const & >::type const operator /=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::divides_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus_assign , Left & , Right & >::type const operator %=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus_assign , Left & , Right const & >::type const operator %=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus_assign , Left const & , Right & >::type const operator %=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::modulus_assign , Left const & , Right const & >::type const operator %=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::modulus_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus_assign , Left & , Right & >::type const operator +=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus_assign , Left & , Right const & >::type const operator +=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus_assign , Left const & , Right & >::type const operator +=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::plus_assign , Left const & , Right const & >::type const operator +=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::plus_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus_assign , Left & , Right & >::type const operator -=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus_assign , Left & , Right const & >::type const operator -=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus_assign , Left const & , Right & >::type const operator -=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::minus_assign , Left const & , Right const & >::type const operator -=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::minus_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and_assign , Left & , Right & >::type const operator &=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and_assign , Left & , Right const & >::type const operator &=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and_assign , Left const & , Right & >::type const operator &=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_and_assign , Left const & , Right const & >::type const operator &=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_and_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or_assign , Left & , Right & >::type const operator |=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or_assign , Left & , Right const & >::type const operator |=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or_assign , Left const & , Right & >::type const operator |=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_or_assign , Left const & , Right const & >::type const operator |=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_or_assign, deduce_domain, Left const &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor_assign , Left & , Right & >::type const operator ^=(Left &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor_assign, deduce_domain, Left &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor_assign , Left & , Right const & >::type const operator ^=(Left &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor_assign, deduce_domain, Left &, Right const &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor_assign , Left const & , Right & >::type const operator ^=(Left const &left, Right &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor_assign, deduce_domain, Left const &, Right &>()(left, right); } template<typename Left, typename Right> inline __attribute__ ((always_inline)) typename boost::proto::detail::enable_binary< deduce_domain , deduce_domain::proto_grammar , boost::mpl::or_<is_extension<Left>, is_extension<Right> > , boost::proto::tag::bitwise_xor_assign , Left const & , Right const & >::type const operator ^=(Left const &left, Right const &right) { return boost::proto::detail::make_expr_<boost::proto::tag::bitwise_xor_assign, deduce_domain, Left const &, Right const &>()(left, right); }
+        template<typename A0, typename A1, typename A2>
+        inline __attribute__ ((always_inline))
+        typename result_of::make_expr<
+            tag::if_else_
+          , deduce_domain
+          , A0 const &
+          , A1 const &
+          , A2 const &
+        >::type const
+        if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+        {
+            return proto::detail::make_expr_<
+                tag::if_else_
+              , deduce_domain
+              , A0 const &
+              , A1 const &
+              , A2 const &
+            >()(a0, a1, a2);
+        }
+    }
+    using exprns_::if_else;
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr, long Arity = Expr::proto_arity_c>
+        struct deep_copy_impl;
+        template<typename Expr>
+        struct deep_copy_impl<Expr, 0>
+        {
+            typedef
+                typename base_expr<
+                    typename Expr::proto_domain
+                  , tag::terminal
+                  , term<typename term_traits<typename Expr::proto_child0>::value_type>
+                >::type
+            expr_type;
+            typedef typename Expr::proto_generator proto_generator;
+            typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+            template<typename Expr2, typename S, typename D>
+            result_type operator()(Expr2 const &e, S const &, D const &) const
+            {
+                return proto_generator()(expr_type::make(e.proto_base().child0));
+            }
+        };
+    }
+    namespace result_of
+    {
+        template<typename Expr>
+        struct deep_copy
+        {
+            typedef
+                typename detail::deep_copy_impl<
+                    typename boost::proto::detail::uncvref<Expr>::type
+                >::result_type
+            type;
+        };
+    }
+    namespace functional
+    {
+        struct deep_copy
+        {
+            typedef void proto_is_callable_;
+            template<typename Sig>
+            struct result;
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef
+                    typename detail::deep_copy_impl<
+                        typename boost::proto::detail::uncvref<Expr>::type
+                    >::result_type
+                type;
+            };
+            template<typename Expr>
+            typename result_of::deep_copy<Expr>::type
+            operator()(Expr const &e) const
+            {
+                return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
+            }
+        };
+    }
+    template<typename Expr>
+    typename proto::result_of::deep_copy<Expr>::type
+    deep_copy(Expr const &e)
+    {
+        return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
+    }
+    struct _deep_copy
+      : proto::transform<_deep_copy>
+    {
+        template<typename E, typename S, typename D>
+        struct impl
+          : detail::deep_copy_impl<typename boost::proto::detail::uncvref<E>::type>
+        {};
+    };
+    namespace detail
+    {
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 1>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list1<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 2>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list2<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 3>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list3<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 4>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list4<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 5>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list5<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 6>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list6<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 7>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list7<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 8>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list8<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 9>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list9<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 10>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list10<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9)
+            };
+            return proto_generator()(that);
+        }
+    };
+    }
+}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  extern istream cin;
+  extern ostream cout;
+  extern ostream cerr;
+  extern ostream clog;
+  extern wistream wcin;
+  extern wostream wcout;
+  extern wostream wcerr;
+  extern wostream wclog;
+  static ios_base::Init __ioinit;
+}
+namespace boost { namespace fusion {
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    inline void
+    for_each_linear(First const&, Last const&, F const&, mpl::true_)
+    {
+    }
+    template <typename First, typename Last, typename F>
+    inline void
+    for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
+    {
+        f(*first);
+        detail::for_each_linear(fusion::next(first), last, f,
+                                result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+    template <typename Sequence, typename F, typename Tag>
+    inline void
+    for_each_dispatch(Sequence& seq, F const& f, Tag)
+    {
+        detail::for_each_linear(
+                                fusion::begin(seq)
+                                , fusion::end(seq)
+                                , f
+                                , result_of::equal_to<
+                                typename result_of::begin<Sequence>::type
+                                , typename result_of::end<Sequence>::type>());
+    }
+    template<int N>
+    struct for_each_unrolled
+    {
+        template<typename I0, typename F>
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            f(*i2);
+            typedef typename result_of::next<I2>::type I3;
+            I3 i3(fusion::next(i2));
+            f(*i3);
+            for_each_unrolled<N-4>::call(fusion::next(i3), f);
+        }
+    };
+    template<>
+    struct for_each_unrolled<3>
+    {
+        template<typename I0, typename F>
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            f(*i2);
+        }
+    };
+    template<>
+    struct for_each_unrolled<2>
+    {
+        template<typename I0, typename F>
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+        }
+    };
+    template<>
+    struct for_each_unrolled<1>
+    {
+        template<typename I0, typename F>
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+        }
+    };
+    template<>
+    struct for_each_unrolled<0>
+    {
+        template<typename It, typename F>
+        static void call(It const&, F const&)
+        {
+        }
+    };
+    template <typename Sequence, typename F>
+    inline void
+    for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        for_each_unrolled<result_of::distance<begin, end>::type::value>::call(fusion::begin(seq), f);
+    }
+    template <typename Sequence, typename F>
+    inline void
+    for_each(Sequence& seq, F const& f, mpl::false_)
+    {
+        detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct for_each;
+    }
+    template <typename Sequence, typename F>
+    void
+    for_each(Sequence& seq, F const& f);
+    template <typename Sequence, typename F>
+    void
+    for_each(Sequence const& seq, F const& f);
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Fun>
+    struct segmented_for_each_fun
+    {
+        explicit segmented_for_each_fun(Fun const& f)
+          : fun(f)
+        {}
+        Fun const& fun;
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef void_ type;
+            typedef mpl::true_ continue_type;
+            static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun)
+            {
+                fusion::for_each(seq, fun.fun);
+                return void_();
+            }
+        };
+    };
+    template <typename Sequence, typename F>
+    inline void
+    for_each(Sequence& seq, F const& f, mpl::true_)
+    {
+        fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
+    }
+}}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct for_each
+        {
+            typedef void type;
+        };
+    }
+    template <typename Sequence, typename F>
+    inline void
+    for_each(Sequence& seq, F const& f)
+    {
+        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
+    }
+    template <typename Sequence, typename F>
+    inline void
+    for_each(Sequence const& seq, F const& f)
+    {
+        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace tagns_ { namespace tag
+    {
+        inline std::ostream &operator <<(std::ostream &sout, terminal const &) { return sout << "terminal"; }
+        inline std::ostream &operator <<(std::ostream &sout, unary_plus const &) { return sout << "unary_plus"; }
+        inline std::ostream &operator <<(std::ostream &sout, negate const &) { return sout << "negate"; }
+        inline std::ostream &operator <<(std::ostream &sout, dereference const &) { return sout << "dereference"; }
+        inline std::ostream &operator <<(std::ostream &sout, complement const &) { return sout << "complement"; }
+        inline std::ostream &operator <<(std::ostream &sout, address_of const &) { return sout << "address_of"; }
+        inline std::ostream &operator <<(std::ostream &sout, logical_not const &) { return sout << "logical_not"; }
+        inline std::ostream &operator <<(std::ostream &sout, pre_inc const &) { return sout << "pre_inc"; }
+        inline std::ostream &operator <<(std::ostream &sout, pre_dec const &) { return sout << "pre_dec"; }
+        inline std::ostream &operator <<(std::ostream &sout, post_inc const &) { return sout << "post_inc"; }
+        inline std::ostream &operator <<(std::ostream &sout, post_dec const &) { return sout << "post_dec"; }
+        inline std::ostream &operator <<(std::ostream &sout, shift_left const &) { return sout << "shift_left"; }
+        inline std::ostream &operator <<(std::ostream &sout, shift_right const &) { return sout << "shift_right"; }
+        inline std::ostream &operator <<(std::ostream &sout, multiplies const &) { return sout << "multiplies"; }
+        inline std::ostream &operator <<(std::ostream &sout, divides const &) { return sout << "divides"; }
+        inline std::ostream &operator <<(std::ostream &sout, modulus const &) { return sout << "modulus"; }
+        inline std::ostream &operator <<(std::ostream &sout, plus const &) { return sout << "plus"; }
+        inline std::ostream &operator <<(std::ostream &sout, minus const &) { return sout << "minus"; }
+        inline std::ostream &operator <<(std::ostream &sout, less const &) { return sout << "less"; }
+        inline std::ostream &operator <<(std::ostream &sout, greater const &) { return sout << "greater"; }
+        inline std::ostream &operator <<(std::ostream &sout, less_equal const &) { return sout << "less_equal"; }
+        inline std::ostream &operator <<(std::ostream &sout, greater_equal const &) { return sout << "greater_equal"; }
+        inline std::ostream &operator <<(std::ostream &sout, equal_to const &) { return sout << "equal_to"; }
+        inline std::ostream &operator <<(std::ostream &sout, not_equal_to const &) { return sout << "not_equal_to"; }
+        inline std::ostream &operator <<(std::ostream &sout, logical_or const &) { return sout << "logical_or"; }
+        inline std::ostream &operator <<(std::ostream &sout, logical_and const &) { return sout << "logical_and"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_and const &) { return sout << "bitwise_and"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_or const &) { return sout << "bitwise_or"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_xor const &) { return sout << "bitwise_xor"; }
+        inline std::ostream &operator <<(std::ostream &sout, comma const &) { return sout << "comma"; }
+        inline std::ostream &operator <<(std::ostream &sout, mem_ptr const &) { return sout << "mem_ptr"; }
+        inline std::ostream &operator <<(std::ostream &sout, assign const &) { return sout << "assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, shift_left_assign const &) { return sout << "shift_left_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, shift_right_assign const &) { return sout << "shift_right_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, multiplies_assign const &) { return sout << "multiplies_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, divides_assign const &) { return sout << "divides_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, modulus_assign const &) { return sout << "modulus_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, plus_assign const &) { return sout << "plus_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, minus_assign const &) { return sout << "minus_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_and_assign const &) { return sout << "bitwise_and_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_or_assign const &) { return sout << "bitwise_or_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, bitwise_xor_assign const &) { return sout << "bitwise_xor_assign"; }
+        inline std::ostream &operator <<(std::ostream &sout, subscript const &) { return sout << "subscript"; }
+        inline std::ostream &operator <<(std::ostream &sout, member const &) { return sout << "member"; }
+        inline std::ostream &operator <<(std::ostream &sout, if_else_ const &) { return sout << "if_else_"; }
+        inline std::ostream &operator <<(std::ostream &sout, function const &) { return sout << "function"; }
+    }}
+    namespace hidden_detail_
+    {
+        struct ostream_wrapper
+        {
+            ostream_wrapper(std::ostream &sout)
+              : sout_(sout)
+            {}
+            std::ostream &sout_;
+        };
+        struct named_any
+        {
+            template<typename T>
+            named_any(T const &)
+              : name_(typeid(T).name())
+            {}
+            char const *name_;
+        };
+        inline std::ostream &operator <<(ostream_wrapper sout_wrap, named_any t)
+        {
+            return sout_wrap.sout_ << t.name_;
+        }
+    }
+    namespace detail
+    {
+        struct display_expr_impl
+        {
+            explicit display_expr_impl(std::ostream &sout, int depth = 0)
+              : depth_(depth)
+              , first_(true)
+              , sout_(sout)
+            {}
+            template<typename Expr>
+            void operator()(Expr const &expr) const
+            {
+                this->impl(expr, mpl::long_<arity_of<Expr>::value>());
+            }
+        private:
+            display_expr_impl(display_expr_impl const &);
+            display_expr_impl &operator =(display_expr_impl const &);
+            template<typename Expr>
+            void impl(Expr const &expr, mpl::long_<0>) const
+            {
+                using namespace hidden_detail_;
+                typedef typename tag_of<Expr>::type tag;
+                this->sout_.width(this->depth_);
+                this->sout_ << (this->first_? "" : ", ");
+                this->sout_ << tag() << "(" << proto::value(expr) << ")\n";
+                this->first_ = false;
+            }
+            template<typename Expr, typename Arity>
+            void impl(Expr const &expr, Arity) const
+            {
+                using namespace hidden_detail_;
+                typedef typename tag_of<Expr>::type tag;
+                this->sout_.width(this->depth_);
+                this->sout_ << (this->first_? "" : ", ");
+                this->sout_ << tag() << "(\n";
+                display_expr_impl display(this->sout_, this->depth_ + 4);
+                fusion::for_each(expr, display);
+                this->sout_.width(this->depth_);
+                this->sout_ << "" << ")\n";
+                this->first_ = false;
+            }
+            int depth_;
+            mutable bool first_;
+            std::ostream &sout_;
+        };
+    }
+    namespace functional
+    {
+        struct display_expr
+        {
+            typedef void proto_is_callable_;
+            typedef void result_type;
+            explicit display_expr(std::ostream &sout = std::cout, int depth = 0)
+              : depth_(depth)
+              , sout_(sout)
+            {}
+            template<typename Expr>
+            void operator()(Expr const &expr) const
+            {
+                detail::display_expr_impl(this->sout_, this->depth_)(expr);
+            }
+        private:
+            int depth_;
+            reference_wrapper<std::ostream> sout_;
+        };
+    }
+    template<typename Expr>
+    void display_expr(Expr const &expr, std::ostream &sout)
+    {
+        functional::display_expr(sout, 0)(expr);
+    }
+    template<typename Expr>
+    void display_expr(Expr const &expr)
+    {
+        functional::display_expr()(expr);
+    }
+    template<typename Grammar, typename Expr>
+    void assert_matches(Expr const & )
+    {
+        enum { mpl_assertion_in_line_230 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (proto::matches<Expr, Grammar>))0, 1 ) ) ) };
+    }
+    template<typename Grammar, typename Expr>
+    void assert_matches_not(Expr const & )
+    {
+        enum { mpl_assertion_in_line_241 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (proto::matches<Expr, Grammar>))0, 1 ) ) ) };
+    }
+}}
+namespace boost { namespace proto { namespace context
+{
+    template<
+        typename Expr
+      , typename Context
+      , long Arity
+    >
+    struct null_eval
+    {};
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 0>
+    {
+        typedef void result_type;
+        void operator()(Expr &, Context &) const
+        {}
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 1>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 2>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 3>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 4>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 5>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 6>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 7>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 8>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 9>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 10>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); proto::eval(proto::child_c< 9>(expr), ctx);
+        }
+    };
+    struct null_context
+    {
+        template<typename Expr, typename ThisContext = null_context const>
+        struct eval
+          : null_eval<Expr, ThisContext>
+        {};
+    };
+}}}
+namespace boost {
+namespace detail{
+template <typename T>
+struct is_member_object_pointer_impl
+{
+   static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value )
+                 ;
+};
+}
+template< typename T > struct is_member_object_pointer : public ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { public: };
+}
+namespace boost {
+template<class T> T * get_pointer(T * p)
+{
+    return p;
+}
+template<class T> T * get_pointer(std::auto_ptr<T> const& p)
+{
+    return p.get();
+}
+}
+namespace boost { namespace type_of {
+    template<typename T>
+        typename enable_if<is_function<T>, T&>::type
+        ensure_obj(T&);
+    template<typename T>
+        typename disable_if<is_function<T>, T&>::type
+        ensure_obj(const T&);
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        namespace anyns
+        {
+            struct any
+            {
+                any(...);
+                any operator=(any);
+                any operator[](any);
+                any operator()(); any operator()( any ); any operator()( any , any ); any operator()( any , any , any ); any operator()( any , any , any , any ); any operator()( any , any , any , any , any ); any operator()( any , any , any , any , any , any ); any operator()( any , any , any , any , any , any , any ); any operator()( any , any , any , any , any , any , any , any ); any operator()( any , any , any , any , any , any , any , any , any );
+                template<typename T>
+                operator T &() const volatile;
+                any operator+();
+                any operator-();
+                any operator*();
+                any operator&();
+                any operator~();
+                any operator!();
+                any operator++();
+                any operator--();
+                any operator++(int);
+                any operator--(int);
+                friend any operator<<(any, any);
+                friend any operator>>(any, any);
+                friend any operator*(any, any);
+                friend any operator/(any, any);
+                friend any operator%(any, any);
+                friend any operator+(any, any);
+                friend any operator-(any, any);
+                friend any operator<(any, any);
+                friend any operator>(any, any);
+                friend any operator<=(any, any);
+                friend any operator>=(any, any);
+                friend any operator==(any, any);
+                friend any operator!=(any, any);
+                friend any operator||(any, any);
+                friend any operator&&(any, any);
+                friend any operator&(any, any);
+                friend any operator|(any, any);
+                friend any operator^(any, any);
+                friend any operator,(any, any);
+                friend any operator->*(any, any);
+                friend any operator<<=(any, any);
+                friend any operator>>=(any, any);
+                friend any operator*=(any, any);
+                friend any operator/=(any, any);
+                friend any operator%=(any, any);
+                friend any operator+=(any, any);
+                friend any operator-=(any, any);
+                friend any operator&=(any, any);
+                friend any operator|=(any, any);
+                friend any operator^=(any, any);
+            };
+        }
+        using anyns::any;
+        template<typename T>
+        struct as_mutable
+        {
+            typedef T &type;
+        };
+        template<typename T>
+        struct as_mutable<T &>
+        {
+            typedef T &type;
+        };
+        template<typename T>
+        struct as_mutable<T const &>
+        {
+            typedef T &type;
+        };
+        template<typename T>
+        T make();
+        template<typename T>
+        typename as_mutable<T>::type make_mutable();
+        template<typename T>
+        struct subscript_wrapper
+          : T
+        {
+            using T::operator[];
+            any operator[](any const &) const volatile;
+        };
+        template<typename T>
+        struct as_subscriptable
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T>
+                  , T
+                >::type
+            type;
+        };
+        template<typename T>
+        struct as_subscriptable<T const>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> const
+                  , T const
+                >::type
+            type;
+        };
+        template<typename T>
+        struct as_subscriptable<T &>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> &
+                  , T &
+                >::type
+            type;
+        };
+        template<typename T>
+        struct as_subscriptable<T const &>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> const &
+                  , T const &
+                >::type
+            type;
+        };
+        template<typename T>
+        typename as_subscriptable<T>::type make_subscriptable();
+        template<typename T>
+        char check_reference(T &);
+        template<typename T>
+        char (&check_reference(T const &))[2];
+        namespace has_get_pointerns
+        {
+            using boost::get_pointer;
+            void *(&get_pointer(...))[2];
+            template<typename T>
+            struct has_get_pointer
+            {
+                static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>()));
+                typedef mpl::bool_<value> type;
+            };
+        }
+        using has_get_pointerns::has_get_pointer;
+        template<typename T>
+        struct classtypeof;
+        template<typename T, typename U>
+        struct classtypeof<T U::*>
+        {
+            typedef U type;
+        };
+    template<typename T, typename U >
+    struct classtypeof<T (U::*)()>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U >
+    struct classtypeof<T (U::*)() const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0>
+    struct classtypeof<T (U::*)(A0)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0>
+    struct classtypeof<T (U::*)(A0) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1>
+    struct classtypeof<T (U::*)(A0 , A1)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1>
+    struct classtypeof<T (U::*)(A0 , A1) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2>
+    struct classtypeof<T (U::*)(A0 , A1 , A2)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2>
+    struct classtypeof<T (U::*)(A0 , A1 , A2) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+    {
+        typedef U type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct classtypeof<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const>
+    {
+        typedef U type;
+    };
+        template<typename T>
+        T &lvalue(T &t)
+        {
+            return t;
+        }
+        template<typename T>
+        T const &lvalue(T const &t)
+        {
+            return t;
+        }
+        template<typename U, typename V, typename T>
+        U *proto_get_pointer(T &t, V *, U *)
+        {
+            return boost::addressof(t);
+        }
+        template<typename U, typename V, typename T>
+        U const *proto_get_pointer(T &t, V *, U const *)
+        {
+            return boost::addressof(t);
+        }
+        template<typename U, typename V, typename T>
+        V *proto_get_pointer(T &t, V *, ...)
+        {
+            return get_pointer(t);
+        }
+        namespace get_pointerns
+        {
+            using boost::get_pointer;
+            template<typename T>
+            typename disable_if_c<has_get_pointer<T>::value, T *>::type
+            get_pointer(T &t)
+            {
+                return boost::addressof(t);
+            }
+            template<typename T>
+            typename disable_if_c<has_get_pointer<T>::value, T const *>::type
+            get_pointer(T const &t)
+            {
+                return boost::addressof(t);
+            }
+            char test_ptr_to_const(void *);
+            char (&test_ptr_to_const(void const *))[2];
+            template<typename U> char test_V_is_a_U(U *);
+            template<typename U> char test_V_is_a_U(U const *);
+            template<typename U> char (&test_V_is_a_U(...))[2];
+            template<typename T, typename Void = void>
+            struct result_of_
+              : boost::tr1_result_of<T>
+            {};
+            template<typename T, typename U, typename V>
+            struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type>
+            {
+                static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>())));
+                static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(boost::proto::detail::proto_get_pointer<U>( boost::proto::detail::lvalue(make<V>()) , (true ? 0 : get_pointer(make<V>())) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(make<V>()))) )));
+                typedef
+                    typename mpl::eval_if_c<
+                        (is_V_a_smart_ptr || is_reference<V>::value)
+                      , mpl::eval_if_c<
+                            is_ptr_to_const
+                          , add_reference<typename add_const<T>::type>
+                          , add_reference<T>
+                        >
+                      , mpl::identity<T>
+                    >::type
+                type;
+            };
+            template<
+                typename T
+              , typename U
+              , bool IsMemPtr = is_member_object_pointer<
+                    typename remove_reference<U>::type
+                >::value
+            >
+            struct mem_ptr_fun
+            {
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<T>() ->* proto::detail::make<U>()))) type; }; static int const
+ sznested_result_type
+                = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<T>() ->* proto::detail::make<U>()))); struct nested_result_type : boost::mpl::if_c< 1 ==
+ sznested_result_type
+                , typename
+ nested_and_hidden_nested_result_type
+                ::type & , typename
+ nested_and_hidden_nested_result_type
+                ::type > {}; typedef typename
+ nested_result_type
+                ::type result_type;
+                result_type operator()(
+                    typename add_reference<typename add_const<T>::type>::type t
+                  , typename add_reference<typename add_const<U>::type>::type u
+                ) const
+                {
+                    return t ->* u;
+                }
+            };
+            template<typename T, typename U>
+            struct mem_ptr_fun<T, U, true>
+            {
+                typedef
+                    typename classtypeof<
+                        typename uncvref<U>::type
+                    >::type
+                V;
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(proto::detail::make_mutable<T>()) , (true ? 0 : get_pointer(proto::detail::make_mutable<T>())) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::detail::make_mutable<T>()))) ) ->* proto::detail::make<U>()))) type; }; static int const
+ sznested_result_type
+                = sizeof(boost::proto::detail::check_reference((boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(proto::detail::make_mutable<T>()) , (true ? 0 : get_pointer(proto::detail::make_mutable<T>())) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::detail::make_mutable<T>()))) ) ->* proto::detail::make<U>()))); struct nested_result_type : boost::mpl::if_c< 1 ==
+ sznested_result_type
+                , typename
+ nested_and_hidden_nested_result_type
+                ::type & , typename
+ nested_and_hidden_nested_result_type
+                ::type > {}; typedef typename
+ nested_result_type
+                ::type result_type;
+                result_type operator()(
+                    typename add_reference<typename add_const<T>::type>::type t
+                  , U u
+                ) const
+                {
+                    return boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(t) , (true ? 0 : get_pointer(t)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(t))) ) ->* u;
+                }
+            };
+        }
+        using get_pointerns::result_of_;
+        using get_pointerns::mem_ptr_fun;
+        template<typename A0, typename A1>
+        struct comma_result
+        {
+            struct nested_and_hidden_nested_type { typedef __typeof__(boost::type_of::ensure_obj(((proto::detail::make<A0>(), proto::detail::make<A1>())))) type; }; static int const sznested_type = sizeof(boost::proto::detail::check_reference(((proto::detail::make<A0>(), proto::detail::make<A1>())))); struct nested_type : boost::mpl::if_c< 1 == sznested_type , typename nested_and_hidden_nested_type::type & , typename nested_and_hidden_nested_type::type > {}; typedef typename nested_type::type type;
+        };
+        template<typename A0>
+        struct comma_result<A0, void>
+        {
+            typedef void type;
+        };
+        template<typename A1>
+        struct comma_result<void, A1>
+        {
+            typedef A1 type;
+        };
+        template<>
+        struct comma_result<void, void>
+        {
+            typedef void type;
+        };
+        template<typename T, typename U = T>
+        struct result_of_fixup
+          : mpl::if_c<is_function<T>::value, T *, U>
+        {};
+        template<typename T, typename U>
+        struct result_of_fixup<T &, U>
+          : result_of_fixup<T, T>
+        {};
+        template<typename T, typename U>
+        struct result_of_fixup<T const &, U>
+          : result_of_fixup<T, T>
+        {};
+        template<typename T, typename U>
+        struct result_of_fixup<T *, U>
+          : result_of_fixup<T, U>
+        {};
+        template<typename R, typename T, typename U>
+        struct result_of_fixup<R T::*, U>
+        {
+            typedef R T::*type;
+        };
+        template<typename T, typename U>
+        struct result_of_fixup<T const, U>
+          : result_of_fixup<T, U>
+        {};
+        template<typename T, typename PMF>
+        struct memfun
+        {
+            typedef typename uncvref<PMF>::type pmf_type;
+            typedef typename classtypeof<pmf_type>::type V;
+            typedef typename boost::tr1_result_of<pmf_type(T)>::type result_type;
+            memfun(T t, PMF p)
+              : obj(t)
+              , pmf(p)
+            {}
+            result_type operator()() const
+            {
+                using namespace boost::proto::detail::get_pointerns;
+                return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)();
+            }
+    template<typename A0>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0);
+    }
+    template<typename A0 , typename A1>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1);
+    }
+    template<typename A0 , typename A1 , typename A2>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline __attribute__ ((always_inline))
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const
+    {
+        using namespace boost::proto::detail::get_pointerns;
+        return (boost::proto::detail::proto_get_pointer<V>( boost::proto::detail::lvalue(obj) , (true ? 0 : get_pointer(obj)) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(obj))) ) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+        private:
+            T obj;
+            PMF pmf;
+        };
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace context
+    {
+        template<
+            typename Expr
+          , typename Context
+          , typename Tag
+          , long Arity
+        >
+        struct default_eval
+        {};
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, tag::terminal, 0>
+        {
+            typedef
+                typename proto::result_of::value<Expr &>::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &) const
+            {
+                return proto::value(expr);
+            }
+        };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::unary_plus, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((+ proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((+ proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return + proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::negate, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((- proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((- proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return - proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::dereference, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((* proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((* proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return * proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::complement, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((~ proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((~ proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return ~ proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::address_of, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((& proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((& proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return & proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::logical_not, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((! proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((! proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return ! proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::pre_inc, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((++ proto::detail::make_mutable<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((++ proto::detail::make_mutable<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return ++ proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::pre_dec, 1> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((-- proto::detail::make_mutable<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((-- proto::detail::make_mutable<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return -- proto::eval(proto::child_c<0>(expr), ctx); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::shift_left, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() << proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() << proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) << proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::shift_right, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() >> proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() >> proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) >> proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::multiplies, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() * proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() * proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) * proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::divides, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() / proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() / proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) / proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::modulus, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() % proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() % proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) % proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::plus, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() + proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() + proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) + proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::minus, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() - proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() - proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) - proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::less, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() < proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() < proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) < proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::greater, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() > proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() > proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) > proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::less_equal, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() <= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() <= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) <= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::greater_equal, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() >= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() >= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) >= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::equal_to, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() == proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() == proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) == proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::not_equal_to, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() != proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() != proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) != proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::logical_or, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() || proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() || proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) || proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::logical_and, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() && proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() && proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) && proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_and, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() & proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() & proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) & proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_or, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() | proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() | proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) | proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_xor, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() ^ proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() ^ proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) ^ proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() = proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() = proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) = proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::shift_left_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() <<= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() <<= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) <<= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::shift_right_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() >>= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() >>= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) >>= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::multiplies_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() *= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() *= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) *= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::divides_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() /= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() /= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) /= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::modulus_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() %= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() %= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) %= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::plus_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() += proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() += proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) += proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::minus_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() -= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() -= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) -= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_and_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() &= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() &= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) &= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_or_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() |= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() |= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) |= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context> struct default_eval<Expr, Context, proto::tag::bitwise_xor_assign, 2> { private: typedef typename proto::result_of::child_c<Expr, 0>::type e0; typedef typename proto::result_of::child_c<Expr, 1>::type e1; typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0; typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() ^= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() ^= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()(Expr &expr, Context &ctx) const { return proto::eval( proto::child_c<0>(expr), ctx) ^= proto::eval(proto::child_c<1>(expr) , ctx ); } };
+        template<typename Expr, typename Context>
+        struct is_member_function_eval
+          : is_member_function_pointer<
+                typename detail::uncvref<
+                    typename proto::result_of::eval<
+                        typename remove_reference<
+                            typename proto::result_of::child_c<Expr, 1>::type
+                        >::type
+                      , Context
+                    >::type
+                >::type
+            >
+        {};
+        template<typename Expr, typename Context, bool IsMemFunCall>
+        struct memfun_eval
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1;
+        public:
+            typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return detail::mem_ptr_fun<r0, r1>()(
+                    proto::eval(proto::child_c<0>(expr), ctx)
+                  , proto::eval(proto::child_c<1>(expr), ctx)
+                );
+            }
+        };
+        template<typename Expr, typename Context>
+        struct memfun_eval<Expr, Context, true>
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1;
+        public:
+            typedef detail::memfun<r0, r1> result_type;
+            result_type const operator ()(Expr &expr, Context &ctx) const
+            {
+                return detail::memfun<r0, r1>(
+                    proto::eval(proto::child_c<0>(expr), ctx)
+                  , proto::eval(proto::child_c<1>(expr), ctx)
+                );
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, tag::mem_ptr, 2>
+          : memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value>
+        {};
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::post_inc, 1>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+        public:
+            struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() ++))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() ++))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx) ++;
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::post_dec, 1>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+        public:
+            struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() --))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() --))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx) --;
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::subscript, 2>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1;
+        public:
+            struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()]))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()]))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx)[proto::eval(proto::child_c<1>(expr), ctx)];
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::if_else_, 3>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::child_c<Expr, 2>::type e2;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e2>::type, Context>::type r2;
+        public:
+            struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>()))) type; }; static int const
+ sznested_result_type
+            = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>()))); struct nested_result_type : boost::mpl::if_c< 1 ==
+ sznested_result_type
+            , typename
+ nested_and_hidden_nested_result_type
+            ::type & , typename
+ nested_and_hidden_nested_result_type
+            ::type > {}; typedef typename
+ nested_result_type
+            ::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx)
+                      ? proto::eval(proto::child_c<1>(expr), ctx)
+                      : proto::eval(proto::child_c<2>(expr), ctx);
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::comma, 2>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e0>::type, Context>::type r0;
+            typedef typename proto::result_of::eval<typename boost::remove_reference<e1>::type, Context>::type r1;
+        public:
+            typedef typename proto::detail::comma_result<r0, r1>::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx), proto::eval(proto::child_c<1>(expr), ctx);
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::function, 1>
+        {
+            typedef
+                typename proto::detail::result_of_fixup<
+                    typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c<Expr, 0>::type >::type , Context >::type
+                >::type
+            function_type;
+            typedef
+                typename boost::tr1_result_of<function_type()>::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return proto::eval(proto::child_c<0>(expr), context)();
+            }
+        };
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::function, 2>
+        {
+            typedef
+                typename proto::detail::result_of_fixup<
+                    typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c<Expr, 0>::type >::type , Context >::type
+                >::type
+            function_type;
+            typedef
+                typename detail::result_of_<
+                    function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c<Expr, 1>::type >::type , Context >::type)
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return this->invoke(
+                    expr
+                  , context
+                  , is_member_function_pointer<function_type>()
+                  , is_member_object_pointer<function_type>()
+                );
+            }
+        private:
+            result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const
+            {
+                return proto::eval(proto::child_c<0>(expr), context)(proto::eval(proto::child_c<1>(expr), context));
+            }
+            result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) const
+            {
+                using namespace boost::proto::detail::get_pointerns;
+                typedef typename detail::classtypeof<function_type>::type class_type;
+                return (
+                    boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                    proto::eval(proto::child_c<0>(expr), context)
+                )();
+            }
+            result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::true_) const
+            {
+                using namespace boost::proto::detail::get_pointerns;
+                typedef typename detail::classtypeof<function_type>::type class_type;
+                return (
+                    boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                    proto::eval(proto::child_c<0>(expr), context)
+                );
+            }
+        };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 3>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 4>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 5>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 6>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 7>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 8>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 9>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 10>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 9>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)) , (true ? 0 : get_pointer(proto::eval(proto::child_c<1>(expr), context))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(proto::eval(proto::child_c<1>(expr), context)))) ) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context));
+        }
+    };
+        struct default_context
+        {
+            template<typename Expr, typename ThisContext = default_context const>
+            struct eval
+              : default_eval<Expr, ThisContext>
+            {};
+        };
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Context>
+        struct callable_context_wrapper
+          : remove_cv<Context>::type
+        {
+            callable_context_wrapper();
+            typedef private_type_ fun_type(...);
+            operator fun_type *() const;
+        private:
+            callable_context_wrapper &operator =(callable_context_wrapper const &);
+        };
+        template<typename T>
+        yes_type check_is_expr_handled(T const &);
+        no_type check_is_expr_handled(private_type_ const &);
+        template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
+        struct is_expr_handled;
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 0>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(stag_, proto::value(sexpr_)), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<
+            typename Expr
+          , typename Context
+          , long Arity
+        >
+        struct callable_eval
+        {};
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 0>
+        {
+            typedef typename proto::result_of::value<Expr const &>::type value_type;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(typename Expr::proto_tag, value_type)
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(typename Expr::proto_tag(), proto::value(expr));
+            }
+        };
+        template<
+            typename Context
+          , typename DefaultCtx
+        >
+        struct callable_context
+        {
+            template<typename Expr, typename ThisContext = Context>
+            struct eval
+              : mpl::if_c<
+                    detail::is_expr_handled<Expr, Context>::value
+                  , callable_eval<Expr, ThisContext>
+                  , typename DefaultCtx::template eval<Expr, Context>
+                >::type
+            {};
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 1>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 1>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 2>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 2>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 3>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 3>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 4>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 4>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 5>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 5>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 6>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 6>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 7>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 7>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 8>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 8>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 9>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 9>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 10>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) , proto::child_c< 9>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 10>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename proto::result_of::child_c< Expr const &, 9>::type child9;
+            typedef
+                typename boost::tr1_result_of<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9
+                    )
+                >::type
+            result_type;
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) , proto::child_c< 9>( expr)
+                );
+            }
+        };
+    }
+}}
+namespace boost { namespace proto
+{
+    struct _expr : transform<_expr>
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Expr result_type;
+            typename impl::expr_param
+            operator()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return e;
+            }
+        };
+    };
+    struct _state : transform<_state>
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef State result_type;
+            typename impl::state_param
+            operator ()(
+                typename impl::expr_param
+              , typename impl::state_param s
+              , typename impl::data_param
+            ) const
+            {
+                return s;
+            }
+        };
+    };
+    struct _data : transform<_data>
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef Data result_type;
+            typename impl::data_param
+            operator ()(
+                typename impl::expr_param
+              , typename impl::state_param
+              , typename impl::data_param d
+            ) const
+            {
+                return d;
+            }
+        };
+    };
+    template<int N>
+    struct _child_c : transform<_child_c<N> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename result_of::child_c<Expr, N>::type
+            result_type;
+            typename result_of::child_c<typename impl::expr_param, N>::type
+            operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return proto::child_c<N>(e);
+            }
+        };
+    };
+    struct _value : transform<_value>
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename result_of::value<Expr>::type
+            result_type;
+            typename result_of::value<typename impl::expr_param>::type
+            operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return proto::value(e);
+            }
+        };
+    };
+    struct _void : transform<_void>
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef void result_type;
+            void operator ()(
+                typename impl::expr_param
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {}
+        };
+    };
+    struct _byref : callable
+    {
+        template<typename Sig>
+        struct result;
+        template<typename This, typename T>
+        struct result<This(T)>
+        {
+            typedef boost::reference_wrapper<T const> const type;
+        };
+        template<typename This, typename T>
+        struct result<This(T &)>
+        {
+            typedef boost::reference_wrapper<T> const type;
+        };
+        template<typename T>
+        boost::reference_wrapper<T> const operator ()(T &t) const
+        {
+            return boost::reference_wrapper<T>(t);
+        }
+        template<typename T>
+        boost::reference_wrapper<T const> const operator ()(T const &t) const
+        {
+            return boost::reference_wrapper<T const>(t);
+        }
+    };
+    struct _byval : callable
+    {
+        template<typename Sig>
+        struct result;
+        template<typename This, typename T>
+        struct result<This(T)>
+        {
+            typedef T type;
+        };
+        template<typename This, typename T>
+        struct result<This(T &)>
+          : result<This(T)>
+        {};
+        template<typename This, typename T>
+        struct result<This(boost::reference_wrapper<T>)>
+          : result<This(T)>
+        {};
+        template<typename T>
+        T operator ()(T const &t) const
+        {
+            return t;
+        }
+        template<typename T>
+        T operator ()(boost::reference_wrapper<T> const &t) const
+        {
+            return t;
+        }
+    };
+    template<>
+    struct is_callable<_expr>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<_state>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<_data>
+      : mpl::true_
+    {};
+    template<int N>
+    struct is_callable<_child_c<N> >
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<_value>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<_byref>
+      : mpl::true_
+    {};
+    template<>
+    struct is_callable<_byval>
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Grammar, typename Tag>
+        struct default_case
+          : not_<_>
+        {};
+        template<typename Grammar>
+        struct default_case<Grammar, tag::terminal>
+          : when<terminal<_>, _value>
+        {};
+        template<typename Grammar>
+        struct default_cases
+        {
+            template<typename Tag>
+            struct case_
+              : default_case<Grammar, Tag>
+            {};
+        };
+        template<typename Grammar> struct default_unary_plus : transform<default_unary_plus<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((+ proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((+ proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return + t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::unary_plus> : when<unary_expr<tag::unary_plus, Grammar>, default_unary_plus<Grammar> > {};
+        template<typename Grammar> struct default_negate : transform<default_negate<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((- proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((- proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return - t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::negate> : when<unary_expr<tag::negate, Grammar>, default_negate<Grammar> > {};
+        template<typename Grammar> struct default_dereference : transform<default_dereference<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((* proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((* proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return * t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::dereference> : when<unary_expr<tag::dereference, Grammar>, default_dereference<Grammar> > {};
+        template<typename Grammar> struct default_complement : transform<default_complement<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((~ proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((~ proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return ~ t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::complement> : when<unary_expr<tag::complement, Grammar>, default_complement<Grammar> > {};
+        template<typename Grammar> struct default_address_of : transform<default_address_of<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((& proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((& proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return & t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::address_of> : when<unary_expr<tag::address_of, Grammar>, default_address_of<Grammar> > {};
+        template<typename Grammar> struct default_logical_not : transform<default_logical_not<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((! proto::detail::make<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((! proto::detail::make<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return ! t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::logical_not> : when<unary_expr<tag::logical_not, Grammar>, default_logical_not<Grammar> > {};
+        template<typename Grammar> struct default_pre_inc : transform<default_pre_inc<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((++ proto::detail::make_mutable<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((++ proto::detail::make_mutable<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return ++ t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::pre_inc> : when<unary_expr<tag::pre_inc, Grammar>, default_pre_inc<Grammar> > {};
+        template<typename Grammar> struct default_pre_dec : transform<default_pre_dec<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((-- proto::detail::make_mutable<r0>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((-- proto::detail::make_mutable<r0>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; return -- t0(proto::child_c<0>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::pre_dec> : when<unary_expr<tag::pre_dec, Grammar>, default_pre_dec<Grammar> > {};
+        template<typename Grammar> struct default_shift_left : transform<default_shift_left<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() << proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() << proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) << t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::shift_left> : when<binary_expr<tag::shift_left, Grammar, Grammar>, default_shift_left<Grammar> > {};
+        template<typename Grammar> struct default_shift_right : transform<default_shift_right<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() >> proto::detail::make_mutable<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() >> proto::detail::make_mutable<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) >> t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::shift_right> : when<binary_expr<tag::shift_right, Grammar, Grammar>, default_shift_right<Grammar> > {};
+        template<typename Grammar> struct default_multiplies : transform<default_multiplies<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() * proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() * proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) * t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::multiplies> : when<binary_expr<tag::multiplies, Grammar, Grammar>, default_multiplies<Grammar> > {};
+        template<typename Grammar> struct default_divides : transform<default_divides<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() / proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() / proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) / t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::divides> : when<binary_expr<tag::divides, Grammar, Grammar>, default_divides<Grammar> > {};
+        template<typename Grammar> struct default_modulus : transform<default_modulus<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() % proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() % proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) % t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::modulus> : when<binary_expr<tag::modulus, Grammar, Grammar>, default_modulus<Grammar> > {};
+        template<typename Grammar> struct default_plus : transform<default_plus<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() + proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() + proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) + t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::plus> : when<binary_expr<tag::plus, Grammar, Grammar>, default_plus<Grammar> > {};
+        template<typename Grammar> struct default_minus : transform<default_minus<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() - proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() - proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) - t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::minus> : when<binary_expr<tag::minus, Grammar, Grammar>, default_minus<Grammar> > {};
+        template<typename Grammar> struct default_less : transform<default_less<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() < proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() < proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) < t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::less> : when<binary_expr<tag::less, Grammar, Grammar>, default_less<Grammar> > {};
+        template<typename Grammar> struct default_greater : transform<default_greater<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() > proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() > proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) > t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::greater> : when<binary_expr<tag::greater, Grammar, Grammar>, default_greater<Grammar> > {};
+        template<typename Grammar> struct default_less_equal : transform<default_less_equal<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() <= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() <= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) <= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::less_equal> : when<binary_expr<tag::less_equal, Grammar, Grammar>, default_less_equal<Grammar> > {};
+        template<typename Grammar> struct default_greater_equal : transform<default_greater_equal<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() >= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() >= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) >= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::greater_equal> : when<binary_expr<tag::greater_equal, Grammar, Grammar>, default_greater_equal<Grammar> > {};
+        template<typename Grammar> struct default_equal_to : transform<default_equal_to<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() == proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() == proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) == t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::equal_to> : when<binary_expr<tag::equal_to, Grammar, Grammar>, default_equal_to<Grammar> > {};
+        template<typename Grammar> struct default_not_equal_to : transform<default_not_equal_to<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() != proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() != proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) != t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::not_equal_to> : when<binary_expr<tag::not_equal_to, Grammar, Grammar>, default_not_equal_to<Grammar> > {};
+        template<typename Grammar> struct default_logical_or : transform<default_logical_or<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() || proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() || proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) || t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::logical_or> : when<binary_expr<tag::logical_or, Grammar, Grammar>, default_logical_or<Grammar> > {};
+        template<typename Grammar> struct default_logical_and : transform<default_logical_and<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() && proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() && proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) && t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::logical_and> : when<binary_expr<tag::logical_and, Grammar, Grammar>, default_logical_and<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_and : transform<default_bitwise_and<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() & proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() & proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) & t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_and> : when<binary_expr<tag::bitwise_and, Grammar, Grammar>, default_bitwise_and<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_or : transform<default_bitwise_or<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() | proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() | proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) | t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_or> : when<binary_expr<tag::bitwise_or, Grammar, Grammar>, default_bitwise_or<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_xor : transform<default_bitwise_xor<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() ^ proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() ^ proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) ^ t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_xor> : when<binary_expr<tag::bitwise_xor, Grammar, Grammar>, default_bitwise_xor<Grammar> > {};
+        template<typename Grammar> struct default_assign : transform<default_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() = proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() = proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) = t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::assign> : when<binary_expr<tag::assign, Grammar, Grammar>, default_assign<Grammar> > {};
+        template<typename Grammar> struct default_shift_left_assign : transform<default_shift_left_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() <<= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() <<= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) <<= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::shift_left_assign> : when<binary_expr<tag::shift_left_assign, Grammar, Grammar>, default_shift_left_assign<Grammar> > {};
+        template<typename Grammar> struct default_shift_right_assign : transform<default_shift_right_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() >>= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() >>= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) >>= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::shift_right_assign> : when<binary_expr<tag::shift_right_assign, Grammar, Grammar>, default_shift_right_assign<Grammar> > {};
+        template<typename Grammar> struct default_multiplies_assign : transform<default_multiplies_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() *= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() *= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) *= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::multiplies_assign> : when<binary_expr<tag::multiplies_assign, Grammar, Grammar>, default_multiplies_assign<Grammar> > {};
+        template<typename Grammar> struct default_divides_assign : transform<default_divides_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() /= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() /= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) /= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::divides_assign> : when<binary_expr<tag::divides_assign, Grammar, Grammar>, default_divides_assign<Grammar> > {};
+        template<typename Grammar> struct default_modulus_assign : transform<default_modulus_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() %= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() %= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) %= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::modulus_assign> : when<binary_expr<tag::modulus_assign, Grammar, Grammar>, default_modulus_assign<Grammar> > {};
+        template<typename Grammar> struct default_plus_assign : transform<default_plus_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() += proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() += proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) += t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::plus_assign> : when<binary_expr<tag::plus_assign, Grammar, Grammar>, default_plus_assign<Grammar> > {};
+        template<typename Grammar> struct default_minus_assign : transform<default_minus_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() -= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() -= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) -= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::minus_assign> : when<binary_expr<tag::minus_assign, Grammar, Grammar>, default_minus_assign<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_and_assign : transform<default_bitwise_and_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() &= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() &= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) &= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_and_assign> : when<binary_expr<tag::bitwise_and_assign, Grammar, Grammar>, default_bitwise_and_assign<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_or_assign : transform<default_bitwise_or_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() |= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() |= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) |= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_or_assign> : when<binary_expr<tag::bitwise_or_assign, Grammar, Grammar>, default_bitwise_or_assign<Grammar> > {};
+        template<typename Grammar> struct default_bitwise_xor_assign : transform<default_bitwise_xor_assign<Grammar> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { private: typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; public: struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() ^= proto::detail::make<r1>()))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() ^= proto::detail::make<r1>()))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type; result_type operator ()( typename impl::expr_param e , typename impl::state_param s , typename impl::data_param d ) const { typename Grammar::template impl<e0, State, Data> t0; typename Grammar::template impl<e1, State, Data> t1; return t0(proto::child_c<0>(e), s, d) ^= t1(proto::child_c<1>(e), s, d); } }; }; template<typename Grammar> struct default_case<Grammar, tag::bitwise_xor_assign> : when<binary_expr<tag::bitwise_xor_assign, Grammar, Grammar>, default_bitwise_xor_assign<Grammar> > {};
+        template<typename Grammar, typename Expr, typename State, typename Data>
+        struct is_member_function_invocation
+          : is_member_function_pointer<
+                typename uncvref<
+                    typename Grammar::template impl<
+                        typename result_of::child_c<Expr, 1>::type
+                      , State
+                      , Data
+                    >::result_type
+                >::type
+            >
+        {};
+        template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall>
+        struct default_mem_ptr_impl
+          : transform_impl<Expr, State, Data>
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+        public:
+            typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
+            result_type operator ()(
+                typename default_mem_ptr_impl::expr_param e
+              , typename default_mem_ptr_impl::state_param s
+              , typename default_mem_ptr_impl::data_param d
+            ) const
+            {
+                typename Grammar::template impl<e0, State, Data> t0;
+                typename Grammar::template impl<e1, State, Data> t1;
+                return detail::mem_ptr_fun<r0, r1>()(
+                    t0(proto::child_c<0>(e), s, d)
+                  , t1(proto::child_c<1>(e), s, d)
+                );
+            }
+        };
+        template<typename Grammar, typename Expr, typename State, typename Data>
+        struct default_mem_ptr_impl<Grammar, Expr, State, Data, true>
+          : transform_impl<Expr, State, Data>
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+        public:
+            typedef detail::memfun<r0, r1> result_type;
+            result_type const operator ()(
+                typename default_mem_ptr_impl::expr_param e
+              , typename default_mem_ptr_impl::state_param s
+              , typename default_mem_ptr_impl::data_param d
+            ) const
+            {
+                typename Grammar::template impl<e0, State, Data> t0;
+                typename Grammar::template impl<e1, State, Data> t1;
+                return detail::memfun<r0, r1>(
+                    t0(proto::child_c<0>(e), s, d)
+                  , t1(proto::child_c<1>(e), s, d)
+                );
+            }
+        };
+        template<typename Grammar>
+        struct default_mem_ptr
+          : transform<default_mem_ptr<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : default_mem_ptr_impl<
+                    Grammar
+                  , Expr
+                  , State
+                  , Data
+                  , is_member_function_invocation<Grammar, Expr, State, Data>::value
+                >
+            {};
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::mem_ptr>
+          : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> >
+        {};
+        template<typename Grammar>
+        struct default_post_inc
+          : transform<default_post_inc<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : transform_impl<Expr, State, Data>
+            {
+            private:
+                typedef typename result_of::child_c<Expr, 0>::type e0;
+                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            public:
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() ++))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() ++))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type;
+                result_type operator ()(
+                    typename impl::expr_param e
+                  , typename impl::state_param s
+                  , typename impl::data_param d
+                ) const
+                {
+                    typename Grammar::template impl<e0, State, Data> t0;
+                    return t0(proto::child_c<0>(e), s, d) ++;
+                }
+            };
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::post_inc>
+          : when<post_inc<Grammar>, default_post_inc<Grammar> >
+        {};
+        template<typename Grammar>
+        struct default_post_dec
+          : transform<default_post_dec<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : transform_impl<Expr, State, Data>
+            {
+            private:
+                typedef typename result_of::child_c<Expr, 0>::type e0;
+                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            public:
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_mutable<r0>() --))) type; }; static int const sznested_result_type = sizeof(boost::proto::detail::check_reference((proto::detail::make_mutable<r0>() --))); struct nested_result_type : boost::mpl::if_c< 1 == sznested_result_type , typename nested_and_hidden_nested_result_type::type & , typename nested_and_hidden_nested_result_type::type > {}; typedef typename nested_result_type::type result_type;
+                result_type operator ()(
+                    typename impl::expr_param e
+                  , typename impl::state_param s
+                  , typename impl::data_param d
+                ) const
+                {
+                    typename Grammar::template impl<e0, State, Data> t0;
+                    return t0(proto::child_c<0>(e), s, d) --;
+                }
+            };
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::post_dec>
+          : when<post_dec<Grammar>, default_post_dec<Grammar> >
+        {};
+        template<typename Grammar>
+        struct default_subscript
+          : transform<default_subscript<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : transform_impl<Expr, State, Data>
+            {
+            private:
+                typedef typename result_of::child_c<Expr, 0>::type e0;
+                typedef typename result_of::child_c<Expr, 1>::type e1;
+                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+            public:
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]))) type; }; static int const
+ sznested_result_type
+                = sizeof(boost::proto::detail::check_reference((proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]))); struct nested_result_type : boost::mpl::if_c< 1 ==
+ sznested_result_type
+                , typename
+ nested_and_hidden_nested_result_type
+                ::type & , typename
+ nested_and_hidden_nested_result_type
+                ::type > {}; typedef typename
+ nested_result_type
+                ::type result_type;
+                result_type operator ()(
+                    typename impl::expr_param e
+                  , typename impl::state_param s
+                  , typename impl::data_param d
+                ) const
+                {
+                    typename Grammar::template impl<e0, State, Data> t0;
+                    typename Grammar::template impl<e1, State, Data> t1;
+                    return t0(proto::child_c<0>(e), s, d) [
+                            t1(proto::child_c<1>(e), s, d) ];
+                }
+            };
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::subscript>
+          : when<subscript<Grammar, Grammar>, default_subscript<Grammar> >
+        {};
+        template<typename Grammar>
+        struct default_if_else_
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : transform_impl<Expr, State, Data>
+            {
+            private:
+                typedef typename result_of::child_c<Expr, 0>::type e0;
+                typedef typename result_of::child_c<Expr, 1>::type e1;
+                typedef typename result_of::child_c<Expr, 2>::type e2;
+                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+                typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
+            public:
+                struct nested_and_hidden_nested_result_type { typedef __typeof__(boost::type_of::ensure_obj((proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>()))) type; }; static int const
+ sznested_result_type
+                = sizeof(boost::proto::detail::check_reference((proto::detail::make<r0>() ? proto::detail::make<r1>() : proto::detail::make<r2>()))); struct nested_result_type : boost::mpl::if_c< 1 ==
+ sznested_result_type
+                , typename
+ nested_and_hidden_nested_result_type
+                ::type & , typename
+ nested_and_hidden_nested_result_type
+                ::type > {}; typedef typename
+ nested_result_type
+                ::type result_type;
+                result_type operator ()(
+                    typename impl::expr_param e
+                  , typename impl::state_param s
+                  , typename impl::data_param d
+                ) const
+                {
+                    typename Grammar::template impl<e0, State, Data> t0;
+                    typename Grammar::template impl<e1, State, Data> t1;
+                    typename Grammar::template impl<e2, State, Data> t2;
+                    return t0(proto::child_c<0>(e), s, d)
+                          ? t1(proto::child_c<1>(e), s, d)
+                          : t2(proto::child_c<2>(e), s, d);
+                }
+            };
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::if_else_>
+          : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> >
+        {};
+        template<typename Grammar>
+        struct default_comma
+          : transform<default_comma<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : transform_impl<Expr, State, Data>
+            {
+            private:
+                typedef typename result_of::child_c<Expr, 0>::type e0;
+                typedef typename result_of::child_c<Expr, 1>::type e1;
+                typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+                typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+            public:
+                typedef typename proto::detail::comma_result<r0, r1>::type result_type;
+                result_type operator ()(
+                    typename impl::expr_param e
+                  , typename impl::state_param s
+                  , typename impl::data_param d
+                ) const
+                {
+                    typename Grammar::template impl<e0, State, Data> t0;
+                    typename Grammar::template impl<e1, State, Data> t1;
+                    return t0(proto::child_c<0>(e), s, d)
+                          , t1(proto::child_c<1>(e), s, d);
+                }
+            };
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::comma>
+          : when<comma<Grammar, Grammar>, default_comma<Grammar> >
+        {};
+        template<typename Grammar, typename Expr, typename State, typename Data, long Arity>
+        struct default_function_impl;
+        template<typename Grammar>
+        struct default_function
+          : transform<default_function<Grammar> >
+        {
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : default_function_impl<
+                    Grammar
+                  , Expr
+                  , State
+                  , Data
+                  , transform_impl<Expr, State, Data>::expr::proto_arity_c
+                >
+            {};
+        };
+        template<typename Grammar>
+        struct default_case<Grammar, tag::function>
+          : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> >
+        {};
+        template<typename Grammar, typename Expr, typename State, typename Data>
+        struct default_function_impl<Grammar, Expr, State, Data, 1>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            typedef
+                typename proto::detail::result_of_fixup<r0>::type
+            function_type;
+            typedef
+                typename boost::tr1_result_of<function_type()>::type
+            result_type;
+            result_type operator ()(
+                typename default_function_impl::expr_param e
+              , typename default_function_impl::state_param s
+              , typename default_function_impl::data_param d
+            ) const
+            {
+                return typename Grammar::template impl<e0, State, Data>()( proto::child_c<0>(e), s, d )();
+            }
+        };
+        template<typename Grammar, typename Expr, typename State, typename Data>
+        struct default_function_impl<Grammar, Expr, State, Data, 2>
+          : transform_impl<Expr, State, Data>
+        {
+            typedef typename result_of::child_c<Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+            typedef typename result_of::child_c<Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+            typedef
+                typename proto::detail::result_of_fixup<r0>::type
+            function_type;
+            typedef
+                typename detail::result_of_<function_type(r1)>::type
+            result_type;
+            result_type operator ()(
+                typename default_function_impl::expr_param e
+              , typename default_function_impl::state_param s
+              , typename default_function_impl::data_param d
+            ) const
+            {
+                return this->invoke(
+                    e
+                  , s
+                  , d
+                  , is_member_function_pointer<function_type>()
+                  , is_member_object_pointer<function_type>()
+                );
+            }
+        private:
+            result_type invoke(
+                typename default_function_impl::expr_param e
+              , typename default_function_impl::state_param s
+              , typename default_function_impl::data_param d
+              , mpl::false_
+              , mpl::false_
+            ) const
+            {
+                return typename Grammar::template impl<e0, State, Data>()( proto::child_c<0>(e), s, d )(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ));
+            }
+            result_type invoke(
+                typename default_function_impl::expr_param e
+              , typename default_function_impl::state_param s
+              , typename default_function_impl::data_param d
+              , mpl::true_
+              , mpl::false_
+            ) const
+            {
+                using namespace boost::proto::detail::get_pointerns;
+                typedef typename detail::classtypeof<function_type>::type class_type;
+                return (
+                    boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                    typename Grammar::template impl<e0, State, Data>()( proto::child_c<0>(e), s, d )
+                )();
+            }
+            result_type invoke(
+                typename default_function_impl::expr_param e
+              , typename default_function_impl::state_param s
+              , typename default_function_impl::data_param d
+              , mpl::false_
+              , mpl::true_
+            ) const
+            {
+                using namespace boost::proto::detail::get_pointerns;
+                typedef typename detail::classtypeof<function_type>::type class_type;
+                return (
+                    boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                    typename Grammar::template impl<e0, State, Data>()( proto::child_c<0>(e), s, d )
+                );
+            }
+        };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 3>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 4>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 5>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 6>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4 , r5)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 7>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 8>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 9>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 10>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename boost::tr1_result_of<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            using namespace boost::proto::detail::get_pointerns;
+            typedef typename detail::classtypeof<function_type>::type class_type;
+            return (
+                boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )) , (true ? 0 : get_pointer(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(typename Grammar::template impl<e1, State, Data>()( proto::child_c<1>(e), s, d )))) ) ->*
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ));
+        }
+    };
+    }
+    template<typename Grammar >
+    struct _default
+      : switch_<detail::default_cases<Grammar> >
+    {};
+    template<typename Grammar>
+    struct is_callable<_default<Grammar> >
+      : mpl::true_
+    {};
+    namespace detail
+    {
+        struct _default
+          : proto::_default<>
+        {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_fold;
+    }
+    template<typename Seq, typename State, typename F>
+    typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State const& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State const& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State& state, F f);
+    template<typename Seq, typename State, typename F>
+    typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State& state, F f);
+}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<typename State, typename It, typename F>
+        struct reverse_fold_lvalue_state
+          : boost::result_of<
+                F(
+                typename add_reference<typename add_const<State>::type>::type,
+                typename fusion::result_of::deref<It>::type)
+            >
+        {};
+        template<typename Result,int N>
+        struct unrolled_reverse_fold
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::prior<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::prior(it0);
+                typedef typename
+                    result_of::prior<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::prior(it1);
+                typedef typename
+                    result_of::prior<
+                        It2
+                    >::type
+                It3;
+                It3 it3 = fusion::prior(it2);
+                typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                typedef typename reverse_fold_lvalue_state<State1,It1,F>::type State2;
+                State2 const state2=f(state1,fusion::deref(it1));
+                typedef typename reverse_fold_lvalue_state<State2,It2,F>::type State3;
+                State3 const state3=f(state2,fusion::deref(it2));
+                return unrolled_reverse_fold<
+                    Result
+                  , N-4
+                >::call(
+                    f(state3,fusion::deref(it3)),
+                    fusion::prior(it3),
+                    f);
+            }
+        };
+        template<typename Result>
+        struct unrolled_reverse_fold<Result,3>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename
+                    result_of::prior<
+                        It0 const
+                    >::type
+                It1;
+                It1 it1 = fusion::prior(it0);
+                typedef typename
+                    result_of::prior<
+                        It1
+                    >::type
+                It2;
+                It2 it2 = fusion::prior(it1);
+                typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                typedef typename reverse_fold_lvalue_state<State1,It1,F>::type State2;
+                State2 const state2=f(state1,fusion::deref(it1));
+                return f(state2,fusion::deref(it2));
+            }
+        };
+        template<typename Result>
+        struct unrolled_reverse_fold<Result,2>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                typedef typename reverse_fold_lvalue_state<State,It0,F>::type State1;
+                State1 const state1=f(state,fusion::deref(it0));
+                return f(
+                    state1,
+                    fusion::deref( fusion::prior(it0)));
+            }
+        };
+        template<typename Result>
+        struct unrolled_reverse_fold<Result,1>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0,F f)
+            {
+                return f(state,
+                    fusion::deref(it0));
+            }
+        };
+        template<typename Result>
+        struct unrolled_reverse_fold<Result,0>
+        {
+            template<typename State, typename It0, typename F>
+            static Result
+            call(State const& state,It0 const& it0, F)
+            {
+                return static_cast<Result>(state);
+            }
+        };
+        template<typename StateRef, typename It0, typename F, int N>
+        struct result_of_unrolled_reverse_fold
+        {
+            typedef typename
+                reverse_fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::prior<
+                    It0 const
+                >::type
+            it1;
+            typedef typename
+                reverse_fold_lvalue_state<
+                    rest1
+                  , it1
+                  , F
+                >::type
+            rest2;
+            typedef typename
+                result_of::prior<it1>::type
+            it2;
+            typedef typename
+                reverse_fold_lvalue_state<
+                    rest2
+                  , it2
+                  , F
+                >::type
+            rest3;
+            typedef typename
+                result_of::prior<it2>::type
+            it3;
+            typedef typename
+                result_of_unrolled_reverse_fold<
+                    typename reverse_fold_lvalue_state<
+                        rest3
+                      , it3
+                      , F
+                    >::type
+                  , typename result_of::prior<
+                        it3
+                    >::type
+                  , F
+                  , N-4
+                >::type
+            type;
+        };
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_reverse_fold<
+            StateRef
+          , It0
+          , F
+          , 3
+        >
+        {
+            typedef typename
+                reverse_fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+            rest1;
+            typedef typename
+                result_of::prior<
+                    It0 const
+                >::type
+            it1;
+            typedef typename
+                reverse_fold_lvalue_state<
+                    typename reverse_fold_lvalue_state<
+                        rest1
+                      , it1
+                      , F
+                    >::type
+                  , typename result_of::prior<
+                        it1 const
+                    >::type const
+                  , F
+                >::type
+            type;
+        };
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_reverse_fold<
+            StateRef
+          , It0
+          , F
+          , 2
+        >
+          : reverse_fold_lvalue_state<
+                typename reverse_fold_lvalue_state<
+                    StateRef
+                  , It0 const
+                  , F
+                >::type
+              , typename result_of::prior<
+                    It0 const
+                >::type const
+              , F
+            >
+        {};
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_reverse_fold<
+            StateRef
+          , It0
+          , F
+          , 1
+        >
+          : reverse_fold_lvalue_state<
+                StateRef
+              , It0 const
+              , F
+            >
+        {};
+        template<typename StateRef, typename It0, typename F>
+        struct result_of_unrolled_reverse_fold<
+            StateRef
+          , It0
+          , F
+          , 0
+        >
+        {
+            typedef StateRef type;
+        };
+        template<typename StateRef, typename It0, typename F, int SeqSize>
+        struct result_of_first_unrolledreverse_fold
+        {
+            typedef typename
+                result_of_unrolled_reverse_fold<
+                    typename boost::result_of<
+                        F(
+                            StateRef,
+                            typename fusion::result_of::deref< It0 const>::type
+                        )
+                    >::type
+                  , typename result_of::prior<
+                        It0 const
+                    >::type
+                  , F
+                  , SeqSize-1
+                >::type
+            type;
+        };
+        template<int SeqSize, typename StateRef, typename Seq, typename F>
+        struct reverse_fold_impl
+        {
+            typedef typename
+                result_of_first_unrolledreverse_fold<
+                    StateRef
+                  , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+                  , F
+                  , SeqSize
+                >::type
+            type;
+            static type
+            call(StateRef state, Seq& seq, F f)
+            {
+                typedef
+                    unrolled_reverse_fold<
+                        type
+                      , SeqSize
+                    >
+                unrolled_impl;
+                return unrolled_impl::call(
+                    state,
+                    fusion::prior( fusion::end(seq)),
+                    f);
+            }
+        };
+        template<typename StateRef, typename Seq, typename F>
+        struct reverse_fold_impl<0,StateRef,Seq,F>
+        {
+            typedef StateRef type;
+            static StateRef
+            call(StateRef state, Seq&, F)
+            {
+                return static_cast<StateRef>(state);
+            }
+        };
+        template<typename Seq, typename State, typename F, bool IsSegmented>
+        struct result_of_reverse_fold
+          : reverse_fold_impl<
+                result_of::size<Seq>::value
+              , typename add_reference<
+                    typename add_const<State>::type
+                >::type
+              , Seq
+              , F
+            >
+        {};
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_fold
+          : detail::result_of_reverse_fold<
+                Seq
+              , State
+              , F
+              , traits::is_segmented<Seq>::type::value
+            >
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State const& state, F f)
+    {
+        return result_of::reverse_fold<Seq,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State const& state, F f)
+    {
+        return result_of::reverse_fold<Seq const,State const,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State& state, F f)
+    {
+        return result_of::reverse_fold<Seq,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+    template<typename Seq, typename State, typename F>
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State& state, F f)
+    {
+        return result_of::reverse_fold<Seq const,State,F>::call(
+            state,
+            seq,
+            f);
+    }
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Transform, typename Data>
+        struct as_callable
+        {
+            as_callable(Data d)
+              : d_(d)
+            {}
+            template<typename Sig>
+            struct result;
+            template<typename This, typename State, typename Expr>
+            struct result<This(State, Expr)>
+            {
+                typedef
+                    typename when<_, Transform>::template impl<Expr, State, Data>::result_type
+                type;
+            };
+            template<typename State, typename Expr>
+            typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
+            operator ()(State const &s, Expr &e) const
+            {
+                return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_);
+            }
+        private:
+            Data d_;
+        };
+        template<
+            typename State0
+          , typename Fun
+          , typename Expr
+          , typename State
+          , typename Data
+          , long Arity = arity_of<Expr>::value
+        >
+        struct fold_impl
+        {};
+        template<
+            typename State0
+          , typename Fun
+          , typename Expr
+          , typename State
+          , typename Data
+          , long Arity = arity_of<Expr>::value
+        >
+        struct reverse_fold_impl
+        {};
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 1>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1;
+        typedef state1 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d );
+            return s1;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state1 s1 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 2>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2;
+        typedef state2 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d );
+            return s2;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state2 s2 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 3>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3;
+        typedef state3 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d );
+            return s3;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state3 s3 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 4>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4;
+        typedef state4 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d );
+            return s4;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state4 s4 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 5>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5;
+        typedef state5 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d );
+            return s5;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state5 s5 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 6>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6;
+        typedef state6 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d );
+            return s6;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state6 s6 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 7>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7;
+        typedef state7 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d );
+            return s7;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state7 s7 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 8>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8;
+        typedef state8 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d );
+            return s8;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state8 s8 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 9>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9;
+        typedef state9 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d );
+            return s9;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state9 s9 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct fold_impl<State0, Fun, Expr, State, Data, 10>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10;
+        typedef state10 result_type;
+        result_type operator ()(
+            typename fold_impl::expr_param e
+          , typename fold_impl::state_param s
+          , typename fold_impl::data_param d
+        ) const
+        {
+            state0 s0 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::child_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d );
+            return s10;
+        }
+    };
+    template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+    struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10;
+        typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+        typedef state0 result_type;
+        result_type operator ()(
+            typename reverse_fold_impl::expr_param e
+          , typename reverse_fold_impl::state_param s
+          , typename reverse_fold_impl::data_param d
+        ) const
+        {
+            state10 s10 =
+                typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+            state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+            return s0;
+        }
+    };
+    }
+    template<typename Sequence, typename State0, typename Fun>
+    struct fold : transform<fold<Sequence, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename remove_reference<
+                    typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
+                >::type
+            sequence;
+            typedef
+                typename remove_reference<
+                    typename when<_, State0>::template impl<Expr, State, Data>::result_type
+                >::type
+            state0;
+            typedef
+                detail::as_callable<Fun, Data>
+            fun;
+            typedef
+                typename fusion::result_of::fold<
+                    sequence
+                  , state0
+                  , fun
+                >::type
+            result_type;
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typename when<_, Sequence>::template impl<Expr, State, Data> seq;
+                detail::as_callable<Fun, Data> f(d);
+                return fusion::fold(
+                    seq(e, s, d)
+                  , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
+                  , f
+                );
+            }
+        };
+    };
+    template<typename Sequence, typename State0, typename Fun>
+    struct reverse_fold : transform<reverse_fold<Sequence, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef
+                typename remove_reference<
+                    typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
+                >::type
+            sequence;
+            typedef
+                typename remove_reference<
+                    typename when<_, State0>::template impl<Expr, State, Data>::result_type
+                >::type
+            state0;
+            typedef
+                detail::as_callable<Fun, Data>
+            fun;
+            typedef
+                typename fusion::result_of::reverse_fold<
+                    sequence
+                  , state0
+                  , fun
+                >::type
+            result_type;
+            result_type operator ()(
+                typename impl::expr_param e
+              , typename impl::state_param s
+              , typename impl::data_param d
+            ) const
+            {
+                typename when<_, Sequence>::template impl<Expr, State, Data> seq;
+                detail::as_callable<Fun, Data> f(d);
+                return fusion::reverse_fold(
+                    seq(e, s, d)
+                  , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
+                  , f
+                );
+            }
+        };
+    };
+    template<typename State0, typename Fun>
+    struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::fold_impl<State0, Fun, Expr, State, Data>
+        {};
+    };
+    template<typename State0, typename Fun>
+    struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : detail::reverse_fold_impl<State0, Fun, Expr, State, Data>
+        {};
+    };
+    template<typename Sequence, typename State, typename Fun>
+    struct is_callable<fold<Sequence, State, Fun> >
+      : mpl::true_
+    {};
+    template<typename Sequence, typename State, typename Fun>
+    struct is_callable<reverse_fold<Sequence, State, Fun> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Tag>
+        struct has_tag
+        {
+            template<typename Expr, typename State, typename Data, typename EnableIf = Tag>
+            struct impl
+            {
+                typedef mpl::false_ result_type;
+            };
+            template<typename Expr, typename State, typename Data>
+            struct impl<Expr, State, Data, typename Expr::proto_tag>
+            {
+                typedef mpl::true_ result_type;
+            };
+            template<typename Expr, typename State, typename Data>
+            struct impl<Expr &, State, Data, typename Expr::proto_tag>
+            {
+                typedef mpl::true_ result_type;
+            };
+        };
+        template<typename Tag, typename Fun>
+        struct fold_tree_
+          : if_<has_tag<Tag>, fold<_, _state, fold_tree_<Tag, Fun> >, Fun>
+        {};
+        template<typename Tag, typename Fun>
+        struct reverse_fold_tree_
+          : if_<has_tag<Tag>, reverse_fold<_, _state, reverse_fold_tree_<Tag, Fun> >, Fun>
+        {};
+    }
+    template<typename Sequence, typename State0, typename Fun>
+    struct fold_tree
+      : transform<fold_tree<Sequence, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : fold<
+                Sequence
+              , State0
+              , detail::fold_tree_<typename Expr::proto_tag, Fun>
+            >::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl<Expr &, State, Data>
+          : fold<
+                Sequence
+              , State0
+              , detail::fold_tree_<typename Expr::proto_tag, Fun>
+            >::template impl<Expr &, State, Data>
+        {};
+    };
+    template<typename Sequence, typename State0, typename Fun>
+    struct reverse_fold_tree
+      : transform<reverse_fold_tree<Sequence, State0, Fun> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : reverse_fold<
+                Sequence
+              , State0
+              , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun>
+            >::template impl<Expr, State, Data>
+        {};
+        template<typename Expr, typename State, typename Data>
+        struct impl<Expr &, State, Data>
+          : reverse_fold<
+                Sequence
+              , State0
+              , detail::reverse_fold_tree_<typename Expr::proto_tag, Fun>
+            >::template impl<Expr &, State, Data>
+        {};
+    };
+    template<typename Sequence, typename State0, typename Fun>
+    struct is_callable<fold_tree<Sequence, State0, Fun> >
+      : mpl::true_
+    {};
+    template<typename Sequence, typename State0, typename Fun>
+    struct is_callable<reverse_fold_tree<Sequence, State0, Fun> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    template<typename T, T I>
+    struct integral_c : transform<integral_c<T, I> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : transform_impl<Expr, State, Data>
+        {
+            typedef T result_type;
+            T operator()(
+                typename impl::expr_param
+              , typename impl::state_param
+              , typename impl::data_param
+            ) const
+            {
+                return I;
+            }
+        };
+    };
+    template<char I>
+    struct char_
+      : integral_c<char, I>
+    {};
+    template<int I>
+    struct int_
+      : integral_c<int, I>
+    {};
+    template<long I>
+    struct long_
+      : integral_c<long, I>
+    {};
+    template<std::size_t I>
+    struct size_t
+      : integral_c<std::size_t, I>
+    {};
+    template<typename T, T I>
+    struct is_callable<integral_c<T, I> >
+      : mpl::true_
+    {};
+    template<char I>
+    struct is_callable<char_<I> >
+      : mpl::true_
+    {};
+    template<int I>
+    struct is_callable<int_<I> >
+      : mpl::true_
+    {};
+    template<long I>
+    struct is_callable<long_<I> >
+      : mpl::true_
+    {};
+    template<std::size_t I>
+    struct is_callable<size_t<I> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto
+{
+    template<typename Object>
+    struct lazy : transform<lazy<Object> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object >
+    struct lazy<Object()>
+      : transform<lazy<Object()> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                ()
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0>
+    struct lazy<Object(A0)>
+      : transform<lazy<Object(A0)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1>
+    struct lazy<Object(A0 , A1)>
+      : transform<lazy<Object(A0 , A1)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct lazy<Object(A0 , A1 , A2)>
+      : transform<lazy<Object(A0 , A1 , A2)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct lazy<Object(A0 , A1 , A2 , A3)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object>
+    struct is_callable<lazy<Object> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace proto { namespace functional
+{
+    struct make_pair
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename First, typename Second>
+        struct result<This(First, Second)>
+        {
+            typedef
+                std::pair<
+                    typename remove_const<typename remove_reference<First>::type>::type
+                  , typename remove_const<typename remove_reference<Second>::type>::type
+                >
+            type;
+        };
+        template<typename First, typename Second>
+        std::pair<First, Second> operator()(First const &first, Second const &second) const
+        {
+            return std::make_pair(first, second);
+        }
+    };
+    struct first
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Pair>
+        struct result<This(Pair)>
+        {
+            typedef typename Pair::first_type type;
+        };
+        template<typename This, typename Pair>
+        struct result<This(Pair &)>
+        {
+            typedef typename Pair::first_type &type;
+        };
+        template<typename This, typename Pair>
+        struct result<This(Pair const &)>
+        {
+            typedef typename Pair::first_type const &type;
+        };
+        template<typename Pair>
+        typename Pair::first_type &operator()(Pair &pair) const
+        {
+            return pair.first;
+        }
+        template<typename Pair>
+        typename Pair::first_type const &operator()(Pair const &pair) const
+        {
+            return pair.first;
+        }
+    };
+    struct second
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Pair>
+        struct result<This(Pair)>
+        {
+            typedef typename Pair::second_type type;
+        };
+        template<typename This, typename Pair>
+        struct result<This(Pair &)>
+        {
+            typedef typename Pair::second_type &type;
+        };
+        template<typename This, typename Pair>
+        struct result<This(Pair const &)>
+        {
+            typedef typename Pair::second_type const &type;
+        };
+        template<typename Pair>
+        typename Pair::second_type &operator()(Pair &pair) const
+        {
+            return pair.second;
+        }
+        template<typename Pair>
+        typename Pair::second_type const &operator()(Pair const &pair) const
+        {
+            return pair.second;
+        }
+    };
+}}}
+namespace boost { namespace proto { namespace functional
+{
+    struct at
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq, typename N>
+        struct result<This(Seq, N)>
+          : fusion::result_of::at<
+                typename boost::remove_reference<Seq>::type
+              , typename boost::remove_const<typename boost::remove_reference<N>::type>::type
+            >
+        {};
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq, N>::type
+        operator ()(Seq &seq, N const & ) const
+        {
+            return fusion::at<N>(seq);
+        }
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq const, N>::type
+        operator ()(Seq const &seq, N const &) const
+        {
+            return fusion::at<N>(seq);
+        }
+    };
+}}}
+namespace boost { namespace proto { namespace functional
+{
+    struct pop_back
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_back<Seq>
+        {};
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            typedef typename fusion::result_of::pop_back<Seq>::type result_type;
+            return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq)));
+        }
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_back(seq);
+        }
+    };
+}}}
+namespace boost { namespace proto { namespace functional
+{
+    struct pop_front
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_front<Seq>
+        {};
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            typedef typename fusion::result_of::pop_front<Seq>::type result_type;
+            return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq));
+        }
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_front(seq);
+        }
+    };
+}}}
+namespace boost { namespace proto { namespace functional
+{
+    struct push_back
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_back<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_back<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_back(seq, t);
+        }
+    };
+}}}
+namespace boost { namespace proto { namespace functional
+{
+    struct push_front
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_front<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_front<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_front(seq, t);
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::deref<
+                        typename result_of::prior<
+                            typename Iterator::first_type
+                        >::type
+                    >::type
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return *fusion::prior(i.first);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template <>
+        struct next_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename prior_impl<typename first_type::fusion_tag>::
+                    template apply<first_type>
+                wrapped;
+                typedef reverse_view_iterator<typename wrapped::type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(wrapped::call(i.first));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template <>
+        struct prior_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename next_impl<typename first_type::fusion_tag>::
+                    template apply<first_type>
+                wrapped;
+                typedef reverse_view_iterator<typename wrapped::type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(wrapped::call(i.first));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct reverse_view_iterator_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template<typename Tag>
+        struct advance_impl;
+        template<>
+        struct advance_impl<reverse_view_iterator_tag>
+        {
+            template<typename Iterator, typename Dist>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename mpl::negate<Dist>::type negative_dist;
+                typedef typename result_of::advance<first_type, negative_dist>::type advanced_type;
+                typedef reverse_view_iterator<advanced_type> type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(boost::fusion::advance<negative_dist>(i.first));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion {
+    struct reverse_view_iterator_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template<typename Tag>
+        struct distance_impl;
+        template<>
+        struct distance_impl<reverse_view_iterator_tag>
+        {
+            template<typename First, typename Last>
+            struct apply
+            {
+                typedef typename First::first_type first_type;
+                typedef typename Last::first_type last_type;
+                typedef typename result_of::distance<last_type, first_type>::type type;
+                static type
+                call(First const& first, Last const& last)
+                {
+                    return boost::fusion::distance(last.first, first.first);
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<reverse_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename
+                    result_of::value_of<
+                        typename result_of::prior<
+                            typename Iterator::first_type
+                        >::type
+                    >::type
+                type;
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct deref_data_impl;
+    template <>
+    struct deref_data_impl<reverse_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+        {
+            typedef typename
+                result_of::deref_data<typename It::first_type>::type
+            type;
+            static type
+            call(It const& it)
+            {
+                return fusion::deref_data(it.first);
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_of_data_impl;
+    template <>
+    struct value_of_data_impl<reverse_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::value_of_data<typename It::first_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct key_of_impl;
+    template <>
+    struct key_of_impl<reverse_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::key_of<typename It::it_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_iterator_tag;
+    template <typename First>
+    struct reverse_view_iterator
+        : iterator_base<reverse_view_iterator<First> >
+    {
+        typedef convert_iterator<First> converter;
+        typedef typename converter::type first_type;
+        typedef reverse_view_iterator_tag fusion_tag;
+        typedef typename traits::category_of<first_type>::type category;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_base_of< bidirectional_traversal_tag , category>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_42;
+        reverse_view_iterator(First const& in_first)
+            : first(converter::call(in_first)) {}
+        first_type first;
+    private:
+        reverse_view_iterator& operator= (reverse_view_iterator const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<reverse_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef reverse_view_iterator<typename Sequence::last_type> type;
+                static type
+                call(Sequence const& s)
+                {
+                    return type(s.last());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_tag;
+    template <typename Iterator>
+    struct reverse_view_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<reverse_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef reverse_view_iterator<typename Sequence::first_type> type;
+                static type
+                call(Sequence const& s)
+                {
+                    return type(s.first());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct at_impl;
+    template <>
+    struct at_impl<reverse_view_tag>
+    {
+        template <typename Seq, typename N>
+        struct apply
+        {
+            typedef mpl::minus<typename Seq::size, mpl::int_<1>, N> real_n;
+            typedef typename
+                result_of::at<typename Seq::seq_type, real_n>::type
+            type;
+            static type
+            call(Seq& seq)
+            {
+                return fusion::at<real_n>(seq.seq);
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_at_impl;
+    template <>
+    struct value_at_impl<reverse_view_tag>
+    {
+        template <typename Seq, typename N>
+        struct apply
+          : result_of::value_at<
+                typename Seq::seq_type
+              , mpl::minus<typename Seq::size, mpl::int_<1>, N>
+            >
+        {};
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct reverse_view_tag;
+    struct fusion_sequence_tag;
+    template <typename Sequence>
+    struct reverse_view : sequence_base<reverse_view<Sequence> >
+    {
+        typedef reverse_view_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef mpl::true_ is_view;
+        typedef Sequence seq_type;
+        typedef typename traits::category_of<Sequence>::type category;
+        typedef typename result_of::begin<Sequence>::type first_type;
+        typedef typename result_of::end<Sequence>::type last_type;
+        typedef typename result_of::size<Sequence>::type size;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_base_of< bidirectional_traversal_tag , typename traits::category_of<first_type>::type>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_50;
+        reverse_view(Sequence& in_seq)
+            : seq(in_seq)
+        {}
+        first_type first() const { return fusion::begin(seq); }
+        last_type last() const { return fusion::end(seq); }
+        typename mpl::if_<traits::is_view<Sequence>, Sequence, Sequence&>::type seq;
+    private:
+        reverse_view& operator= (reverse_view const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct reverse
+        {
+            typedef reverse_view<Sequence> type;
+        };
+    }
+    template <typename Sequence>
+    inline reverse_view<Sequence const>
+    reverse(Sequence const& view)
+    {
+        return reverse_view<Sequence const>(view);
+    }
+}}
+namespace boost { namespace proto { namespace functional
+{
+    struct reverse
+    {
+        typedef void proto_is_callable_;
+        template<typename Sig>
+        struct result;
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::reverse<Seq>
+        {};
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            typedef typename fusion::result_of::reverse<Seq>::type result_type;
+            return result_type(seq);
+        }
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::reverse(seq);
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct void_;
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    struct vector_n_chooser
+    {
+        typedef vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> type;
+    };
+    template <>
+    struct vector_n_chooser<void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector0<> type;
+    };
+    template <typename T0>
+    struct vector_n_chooser<
+        T0
+        , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector1<T0> type;
+    };
+    template <typename T0 , typename T1>
+    struct vector_n_chooser<
+        T0 , T1
+        , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector2<T0 , T1> type;
+    };
+    template <typename T0 , typename T1 , typename T2>
+    struct vector_n_chooser<
+        T0 , T1 , T2
+        , void_ , void_ , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector3<T0 , T1 , T2> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3
+        , void_ , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector4<T0 , T1 , T2 , T3> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3 , T4
+        , void_ , void_ , void_ , void_ , void_>
+    {
+        typedef vector5<T0 , T1 , T2 , T3 , T4> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3 , T4 , T5
+        , void_ , void_ , void_ , void_>
+    {
+        typedef vector6<T0 , T1 , T2 , T3 , T4 , T5> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3 , T4 , T5 , T6
+        , void_ , void_ , void_>
+    {
+        typedef vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        , void_ , void_>
+    {
+        typedef vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> type;
+    };
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    struct vector_n_chooser<
+        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        , void_>
+    {
+        typedef vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    struct fusion_sequence_tag;
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    struct vector
+        : sequence_base<vector<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> >
+    {
+    private:
+        typedef typename detail::vector_n_chooser<
+            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::type
+        vector_n;
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+        friend struct vector;
+    public:
+        typedef typename vector_n::types types;
+        typedef typename vector_n::fusion_tag fusion_tag;
+        typedef typename vector_n::tag tag;
+        typedef typename vector_n::size size;
+        typedef typename vector_n::category category;
+        typedef typename vector_n::is_view is_view;
+        vector()
+            : vec() {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+        vector(vector<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
+            : vec(rhs.vec) {}
+        vector(vector const& rhs)
+            : vec(rhs.vec) {}
+        template <typename Sequence>
+        vector(Sequence const& rhs)
+            : vec(rhs) {}
+    explicit
+    vector(typename detail::call_param<T0 >::type _0)
+        : vec(_0) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1)
+        : vec(_0 , _1) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2)
+        : vec(_0 , _1 , _2) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3)
+        : vec(_0 , _1 , _2 , _3) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4)
+        : vec(_0 , _1 , _2 , _3 , _4) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5)
+        : vec(_0 , _1 , _2 , _3 , _4 , _5) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6)
+        : vec(_0 , _1 , _2 , _3 , _4 , _5 , _6) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7)
+        : vec(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8)
+        : vec(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
+    vector(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8 , typename detail::call_param<T9 >::type _9)
+        : vec(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
+        template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+        vector&
+        operator=(vector<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
+        {
+            vec = rhs.vec;
+            return *this;
+        }
+        template <typename T>
+        vector&
+        operator=(T const& rhs)
+        {
+            vec = rhs;
+            return *this;
+        }
+        template <int N>
+        typename add_reference<
+            typename mpl::at_c<types, N>::type
+        >::type
+        at_impl(mpl::int_<N> index)
+        {
+            return vec.at_impl(index);
+        }
+        template <int N>
+        typename add_reference<
+            typename add_const<
+                typename mpl::at_c<types, N>::type
+            >::type
+        >::type
+        at_impl(mpl::int_<N> index) const
+        {
+            return vec.at_impl(index);
+        }
+        template <typename I>
+        typename add_reference<
+            typename mpl::at<types, I>::type
+        >::type
+        at_impl(I )
+        {
+            return vec.at_impl(mpl::int_<I::value>());
+        }
+        template<typename I>
+        typename add_reference<
+            typename add_const<
+                typename mpl::at<types, I>::type
+            >::type
+        >::type
+        at_impl(I ) const
+        {
+            return vec.at_impl(mpl::int_<I::value>());
+        }
+    private:
+        vector_n vec;
+    };
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <int size>
+    struct as_vector;
+    template <>
+    struct as_vector<0>
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef vector0<> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator)
+        {
+            return vector0<>();
+        }
+    };
+}}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <>
+    struct as_vector<1>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1;
+            typedef typename fusion::result_of::value_of<I0>::type T0;
+            typedef vector1<T0> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            return result(*i0);
+        }
+    };
+    template <>
+    struct as_vector<2>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1;
+            typedef vector2<T0 , T1> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0);
+            return result(*i0 , *i1);
+        }
+    };
+    template <>
+    struct as_vector<3>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2;
+            typedef vector3<T0 , T1 , T2> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1);
+            return result(*i0 , *i1 , *i2);
+        }
+    };
+    template <>
+    struct as_vector<4>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3;
+            typedef vector4<T0 , T1 , T2 , T3> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2);
+            return result(*i0 , *i1 , *i2 , *i3);
+        }
+    };
+    template <>
+    struct as_vector<5>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4;
+            typedef vector5<T0 , T1 , T2 , T3 , T4> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4);
+        }
+    };
+    template <>
+    struct as_vector<6>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5;
+            typedef vector6<T0 , T1 , T2 , T3 , T4 , T5> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3); typename gen::I5 i5 = fusion::next(i4);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4 , *i5);
+        }
+    };
+    template <>
+    struct as_vector<7>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6;
+            typedef vector7<T0 , T1 , T2 , T3 , T4 , T5 , T6> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3); typename gen::I5 i5 = fusion::next(i4); typename gen::I6 i6 = fusion::next(i5);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6);
+        }
+    };
+    template <>
+    struct as_vector<8>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7;
+            typedef vector8<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3); typename gen::I5 i5 = fusion::next(i4); typename gen::I6 i6 = fusion::next(i5); typename gen::I7 i7 = fusion::next(i6);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7);
+        }
+    };
+    template <>
+    struct as_vector<9>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8;
+            typedef vector9<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3); typename gen::I5 i5 = fusion::next(i4); typename gen::I6 i6 = fusion::next(i5); typename gen::I7 i7 = fusion::next(i6); typename gen::I8 i8 = fusion::next(i7);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8);
+        }
+    };
+    template <>
+    struct as_vector<10>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9;
+            typedef vector10<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> type;
+        };
+        template <typename Iterator>
+        static typename apply<Iterator>::type
+        call(Iterator const& i0)
+        {
+            typedef apply<Iterator> gen;
+            typedef typename gen::type result;
+            typename gen::I1 i1 = fusion::next(i0); typename gen::I2 i2 = fusion::next(i1); typename gen::I3 i3 = fusion::next(i2); typename gen::I4 i4 = fusion::next(i3); typename gen::I5 i5 = fusion::next(i4); typename gen::I6 i6 = fusion::next(i5); typename gen::I7 i7 = fusion::next(i6); typename gen::I8 i8 = fusion::next(i7); typename gen::I9 i9 = fusion::next(i8);
+            return result(*i0 , *i1 , *i2 , *i3 , *i4 , *i5 , *i6 , *i7 , *i8 , *i9);
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct vector_tag;
+    namespace extension
+    {
+        template <typename T>
+        struct convert_impl;
+        template <>
+        struct convert_impl<vector_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename detail::as_vector<result_of::size<Sequence>::value> gen;
+                typedef typename gen::
+                    template apply<typename result_of::begin<Sequence>::type>::type
+                type;
+                static type call(Sequence& seq)
+                {
+                    return gen::call(fusion::begin(seq));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct as_vector
+        {
+            typedef typename detail::as_vector<result_of::size<Sequence>::value> gen;
+            typedef typename gen::
+                template apply<typename result_of::begin<Sequence>::type>::type
+            type;
+        };
+    }
+    template <typename Sequence>
+    inline typename result_of::as_vector<Sequence>::type
+    as_vector(Sequence& seq)
+    {
+        typedef typename result_of::as_vector<Sequence>::gen gen;
+        return gen::call(fusion::begin(seq));
+    }
+    template <typename Sequence>
+    inline typename result_of::as_vector<Sequence const>::type
+    as_vector(Sequence const& seq)
+    {
+        typedef typename result_of::as_vector<Sequence const>::gen gen;
+        return gen::call(fusion::begin(seq));
+    }
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct vector11
+    : v_item<
+          T10
+        , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+        >
+{
+    typedef vector11 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct vector12
+    : v_item<
+          T11
+        , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+        >
+{
+    typedef vector12 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct vector13
+    : v_item<
+          T12
+        , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+        >
+{
+    typedef vector13 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct vector14
+    : v_item<
+          T13
+        , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+        >
+{
+    typedef vector14 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct vector15
+    : v_item<
+          T14
+        , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+        >
+{
+    typedef vector15 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct vector16
+    : v_item<
+          T15
+        , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
+        >
+{
+    typedef vector16 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct vector17
+    : v_item<
+          T16
+        , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
+        >
+{
+    typedef vector17 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct vector18
+    : v_item<
+          T17
+        , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
+        >
+{
+    typedef vector18 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct vector19
+    : v_item<
+          T18
+        , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
+        >
+{
+    typedef vector19 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct vector20
+    : v_item<
+          T19
+        , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
+        >
+{
+    typedef vector20 type;
+};
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Pred, typename InsertOp > struct remove_if_helper
+{
+    template< typename Sequence, typename U > struct apply
+    {
+        typedef typename eval_if<
+              typename apply1<Pred,U>::type
+            , identity<Sequence>
+            , apply2<InsertOp,Sequence,U>
+            >::type type;
+    };
+};
+template<
+      typename Sequence
+    , typename Predicate
+    , typename Inserter
+    >
+struct remove_if_impl
+    : fold<
+          Sequence
+        , typename Inserter::state
+        , protect< aux::remove_if_helper<
+              typename lambda<Predicate>::type
+            , typename Inserter::operation
+            > >
+        >
+{
+};
+template<
+      typename Sequence
+    , typename Predicate
+    , typename Inserter
+    >
+struct reverse_remove_if_impl
+    : reverse_fold<
+          Sequence
+        , typename Inserter::state
+        , protect< aux::remove_if_helper<
+              typename lambda<Predicate>::type
+            , typename Inserter::operation
+            > >
+        >
+{
+};
+}
+ template< typename P1 = na , typename P2 = na , typename P3 = na > struct remove_if : aux::remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct remove_if< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_remove_if : aux::reverse_remove_if_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_remove_if< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_remove_if_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::remove_if_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef remove_if< na , na , na > result_; typedef remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< remove_if< na , na , na > > : int_<-1> { }; } template<> struct reverse_remove_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_remove_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_remove_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_remove_if< na , na , na > result_; typedef reverse_remove_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_remove_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_remove_if< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename T1 >
+struct same_as
+{
+    template< typename T2 > struct apply
+        : is_same<T1,T2>
+    {
+    };
+};
+template< typename T1 >
+struct not_same_as
+{
+    template< typename T2 > struct apply
+        : not_< is_same<T1,T2> >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template<
+      typename Sequence
+    , typename T
+    , typename Inserter
+    >
+struct remove_impl
+    : remove_if_impl< Sequence, same_as<T>, Inserter >
+{
+};
+template<
+      typename Sequence
+    , typename T
+    , typename Inserter
+    >
+struct reverse_remove_impl
+    : reverse_remove_if_impl< Sequence, same_as<T>, Inserter >
+{
+};
+}
+ template< typename P1 = na , typename P2 = na , typename P3 = na > struct remove : aux::remove_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct remove< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::remove_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_remove_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_remove : aux::reverse_remove_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_remove< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_remove_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::remove_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct remove< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : remove< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< remove< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef remove< na , na , na > result_; typedef remove< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< remove< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< remove< na , na , na > > : int_<-1> { }; } template<> struct reverse_remove< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_remove< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_remove< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_remove< na , na , na > result_; typedef reverse_remove< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_remove< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_remove< na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Iterator = na
+    >
+struct iterator_category
+{
+    typedef typename Iterator::category type;
+};
+template<> struct iterator_category< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_category< T1 > { }; }; template< typename Tag > struct lambda< iterator_category< na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_category< na > result_; typedef iterator_category< na > type; }; namespace aux { template< typename T1 > struct template_arity< iterator_category< T1 > > : int_<1> { }; template<> struct template_arity< iterator_category< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct min
+    : if_< less<N1,N2>,N1,N2 >
+{
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct max
+    : if_< less<N1,N2>,N2,N1 >
+{
+};
+template<> struct min< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : min< T1 , T2 > { }; }; template< typename Tag > struct lambda< min< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef min< na , na > result_; typedef min< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< min< T1 , T2 > > : int_<2> { }; template<> struct template_arity< min< na , na > > : int_<-1> { }; }
+template<> struct max< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max< T1 , T2 > { }; }; template< typename Tag > struct lambda< max< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef max< na , na > result_; typedef max< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< max< T1 , T2 > > : int_<2> { }; template<> struct template_arity< max< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+namespace aux {
+struct pair_iter_tag;
+}
+template<
+      typename Iter1
+    , typename Iter2
+    , typename Category
+    >
+struct pair_iter
+{
+    typedef aux::pair_iter_tag tag;
+    typedef Category category;
+    typedef Iter1 first;
+    typedef Iter2 second;
+};
+template< typename Iter1, typename Iter2, typename C >
+struct deref< pair_iter<Iter1,Iter2,C> >
+{
+    typedef pair<
+          typename deref<Iter1>::type
+        , typename deref<Iter2>::type
+        > type;
+};
+template< typename Iter1, typename Iter2, typename C >
+struct next< pair_iter<Iter1,Iter2,C> >
+{
+    typedef typename mpl::next<Iter1>::type i1_;
+    typedef typename mpl::next<Iter2>::type i2_;
+    typedef pair_iter<i1_,i2_,C> type;
+};
+template< typename Iter1, typename Iter2, typename C >
+struct prior< pair_iter<Iter1,Iter2,C> >
+{
+    typedef typename mpl::prior<Iter1>::type i1_;
+    typedef typename mpl::prior<Iter2>::type i2_;
+    typedef pair_iter<i1_,i2_,C> type;
+};
+template<> struct advance_impl<aux::pair_iter_tag>
+{
+    template< typename Iter, typename D > struct apply
+    {
+        typedef typename mpl::advance< typename Iter::first,D >::type i1_;
+        typedef typename mpl::advance< typename Iter::second,D >::type i2_;
+        typedef pair_iter<i1_,i2_,typename Iter::category> type;
+    };
+};
+template<> struct distance_impl<aux::pair_iter_tag>
+{
+    template< typename Iter1, typename Iter2 > struct apply
+    {
+        typedef typename mpl::distance<
+              typename first<Iter1>::type
+            , typename first<Iter2>::type
+            >::type type;
+    };
+};
+template<
+      typename Sequence1 = na
+    , typename Sequence2 = na
+    >
+struct pair_view
+{
+    typedef nested_begin_end_tag tag;
+    typedef typename begin<Sequence1>::type iter1_;
+    typedef typename begin<Sequence2>::type iter2_;
+    typedef typename min<
+          typename iterator_category<iter1_>::type
+        , typename iterator_category<iter2_>::type
+        >::type category_;
+    typedef pair_iter<iter1_,iter2_,category_> begin;
+    typedef pair_iter<
+          typename end<Sequence1>::type
+        , typename end<Sequence2>::type
+        , category_
+        > end;
+};
+template<> struct pair_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair_view< na , na > result_; typedef pair_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair_view< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template<
+      typename Seq
+    , typename Op
+    , typename In
+    >
+struct transform1_impl
+    : fold<
+          Seq
+        , typename In::state
+        , bind2< typename lambda< typename In::operation >::type
+            , _1
+            , bind1< typename lambda<Op>::type, _2>
+            >
+        >
+{
+};
+template<
+      typename Seq
+    , typename Op
+    , typename In
+    >
+struct reverse_transform1_impl
+    : reverse_fold<
+          Seq
+        , typename In::state
+        , bind2< typename lambda< typename In::operation >::type
+            , _1
+            , bind1< typename lambda<Op>::type, _2>
+            >
+        >
+{
+};
+template<
+      typename Seq1
+    , typename Seq2
+    , typename Op
+    , typename In
+    >
+struct transform2_impl
+    : fold<
+          pair_view<Seq1,Seq2>
+        , typename In::state
+        , bind2< typename lambda< typename In::operation >::type
+            , _1
+            , bind2<
+                  typename lambda<Op>::type
+                , bind1<first<>,_2>
+                , bind1<second<>,_2>
+                >
+            >
+        >
+{
+};
+template<
+      typename Seq1
+    , typename Seq2
+    , typename Op
+    , typename In
+    >
+struct reverse_transform2_impl
+    : reverse_fold<
+          pair_view<Seq1,Seq2>
+        , typename In::state
+        , bind2< typename lambda< typename In::operation >::type
+            , _1
+            , bind2< typename lambda< Op >::type
+                , bind1<first<>,_2>
+                , bind1<second<>,_2>
+                >
+            >
+        >
+{
+};
+}
+ template< typename P1 = na , typename P2 = na , typename P3 = na > struct transform1 : aux::transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct transform1< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_transform1 : aux::reverse_transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_transform1< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform1< na , na , na > result_; typedef transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< transform1< na , na , na > > : int_<-1> { }; } template<> struct reverse_transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform1< na , na , na > result_; typedef reverse_transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_transform1< na , na , na > > : int_<-1> { }; }
+ template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct transform2 : aux::transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct transform2< P1 , P2 , P3,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct reverse_transform2 : aux::reverse_transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct reverse_transform2< P1 , P2 , P3,na > : if_< has_push_back<P1> , aux::reverse_transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform2< na , na , na , na > result_; typedef transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform2< na , na , na , na > > : int_<-1> { }; } template<> struct reverse_transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform2< na , na , na , na > result_; typedef reverse_transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform2< na , na , na , na > > : int_<-1> { }; }
+template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , transform1<Seq1,Seq2OrOperation,OperationOrInserter> , transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform< na , na , na , na > result_; typedef transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform< na , na , na , na > > : int_<-1> { }; }
+template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct reverse_transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , reverse_transform1<Seq1,Seq2OrOperation,OperationOrInserter> , reverse_transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct reverse_transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform< na , na , na , na > result_; typedef reverse_transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform< na , na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace phoenix
+{
+    template <
+ typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ >
+    class basic_environment
+    {
+        typedef
+            mpl::vector10<
+                T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+        args_with_void_type;
+    public:
+        typedef typename
+            mpl::remove<args_with_void_type, fusion::void_>::type
+        args_type;
+        typedef typename
+            fusion::result_of::as_vector<
+                typename mpl::transform<
+                    args_type, boost::add_reference<mpl::_1>
+                >::type
+            >::type
+        tie_type;
+        basic_environment()
+            : args_() {}
+        template <typename U0>
+        explicit basic_environment(U0& _0)
+            : args_(_0) {}
+        template <typename U0, typename U1>
+        basic_environment(U0& _0, U1& _1)
+            : args_(_0, _1) {}
+    template < typename U0 , typename U1 , typename U2>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2)
+        : args_( _0 , _1 , _2) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3)
+        : args_( _0 , _1 , _2 , _3) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4)
+        : args_( _0 , _1 , _2 , _3 , _4) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5)
+        : args_( _0 , _1 , _2 , _3 , _4 , _5) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6)
+        : args_( _0 , _1 , _2 , _3 , _4 , _5 , _6) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7)
+        : args_( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7 , U8 & _8)
+        : args_( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+    basic_environment( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7 , U8 & _8 , U9 & _9)
+        : args_( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
+        tie_type const&
+        args() const
+        {
+            return args_;
+        }
+        tie_type&
+        args()
+        {
+            return args_;
+        }
+    private:
+        tie_type args_;
+    };
+}}
+namespace boost { namespace phoenix
+{
+    typedef fusion::void_ void_;
+    namespace detail
+    {
+        template <typename T0, typename T1>
+        struct make_assign_composite;
+        template <typename T0, typename T1>
+        struct make_index_composite;
+        template <typename BaseT0, typename BaseT1>
+        struct comma_result;
+        struct error_expecting_arguments
+        {
+            template <typename T>
+            error_expecting_arguments(T const&) {}
+        };
+    }
+    template <typename Eval, typename Env>
+    struct eval_result
+    {
+        typedef typename Eval::template result<Env>::type type;
+    };
+    template <typename Eval>
+    struct actor : Eval
+    {
+        typedef actor<Eval> self_type;
+        typedef Eval eval_type;
+        template <class Sig> struct result {};
+        actor()
+            : Eval() {}
+        actor(Eval const& base)
+            : Eval(base) {}
+        template <typename T0>
+        explicit actor(T0 const& _0)
+            : Eval(_0) {}
+        template <typename T0, typename T1>
+        actor(T0 const& _0, T1 const& _1)
+            : Eval(_0, _1) {}
+        typedef typename
+            mpl::eval_if<
+                typename Eval::no_nullary
+              , mpl::identity<detail::error_expecting_arguments>
+              , eval_result<eval_type, basic_environment<> >
+            >::type
+        nullary_result;
+        actor& operator=(actor const& rhs)
+        {
+            Eval::operator=(rhs);
+            return *this;
+        }
+        actor& operator=(actor& rhs)
+        {
+            Eval::operator=(rhs);
+            return *this;
+        }
+        nullary_result
+        operator()() const
+        {
+            return eval_type::eval(basic_environment<>());
+        }
+        template <class F, class A0>
+        struct result<F(A0)>
+          : eval_result<
+                eval_type
+              , basic_environment<
+                    typename remove_reference<A0>::type
+                >
+            >
+        {};
+        template <typename T0>
+        typename result<actor(T0&)>::type
+        operator()(T0& _0) const
+        {
+            return eval_type::eval(basic_environment<T0>(_0));
+        }
+        template <class F, class A0, class A1>
+        struct result<F(A0,A1)>
+          : eval_result<
+                eval_type
+              , basic_environment<
+                    typename remove_reference<A0>::type
+                  , typename remove_reference<A1>::type
+                >
+            >
+        {};
+        template <typename T0, typename T1>
+        typename result<actor(T0&,T1&)>::type
+        operator()(T0& _0, T1& _1) const
+        {
+            return eval_type::eval(basic_environment<T0, T1>(_0, _1));
+        }
+        template <typename T1>
+        typename detail::make_assign_composite<self_type, T1>::type
+        operator=(T1 const& a1) const;
+        template <typename T1>
+        typename detail::make_index_composite<self_type, T1>::type
+        operator[](T1 const& a1) const;
+    template < typename T0 , typename T1 , typename T2>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2)
+        : Eval( _0 , _1 , _2) {}
+    template <typename F, typename A0 , typename A1 , typename A2>
+    struct result<F( A0 , A1 , A2)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2>
+    typename result<
+        actor( T0 & , T1 & , T2 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2>(
+                _0 , _1 , _2)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3)
+        : Eval( _0 , _1 , _2 , _3) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
+    struct result<F( A0 , A1 , A2 , A3)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3>(
+                _0 , _1 , _2 , _3)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4)
+        : Eval( _0 , _1 , _2 , _3 , _4) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct result<F( A0 , A1 , A2 , A3 , A4)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4>(
+                _0 , _1 , _2 , _3 , _4)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5)
+        : Eval( _0 , _1 , _2 , _3 , _4 , _5) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct result<F( A0 , A1 , A2 , A3 , A4 , A5)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & , T5 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4 , T5 & _5) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4 , T5>(
+                _0 , _1 , _2 , _3 , _4 , _5)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6)
+        : Eval( _0 , _1 , _2 , _3 , _4 , _5 , _6) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct result<F( A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & , T5 & , T6 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4 , T5 & _5 , T6 & _6) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4 , T5 , T6>(
+                _0 , _1 , _2 , _3 , _4 , _5 , _6)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7)
+        : Eval( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct result<F( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & , T5 & , T6 & , T7 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4 , T5 & _5 , T6 & _6 , T7 & _7) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>(
+                _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8)
+        : Eval( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct result<F( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & , T5 & , T6 & , T7 & , T8 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4 , T5 & _5 , T6 & _6 , T7 & _7 , T8 & _8) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>(
+                _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8)
+        );
+    }
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    actor( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8 , T9 const& _9)
+        : Eval( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
+    template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct result<F( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : eval_result<
+            eval_type
+          , basic_environment<
+ typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type , typename remove_reference<A9 >::type
+            >
+        >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    typename result<
+        actor( T0 & , T1 & , T2 & , T3 & , T4 & , T5 & , T6 & , T7 & , T8 & , T9 & )
+    >::type
+    operator()( T0 & _0 , T1 & _1 , T2 & _2 , T3 & _3 , T4 & _4 , T5 & _5 , T6 & _6 , T7 & _7 , T8 & _8 , T9 & _9) const
+    {
+        return eval_type::eval(
+            basic_environment< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>(
+                _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9)
+        );
+    }
+    };
+    namespace detail
+    {
+        template <typename BaseT0, typename BaseT1>
+        struct comma_result;
+    }
+    template <typename BaseT0, typename BaseT1>
+    typename detail::comma_result<BaseT0, BaseT1>::type
+    operator,(actor<BaseT0> const& a0, actor<BaseT1> const& a1);
+}}
+namespace boost
+{
+    template <typename Eval>
+    struct result_of<phoenix::actor<Eval>()>
+    {
+        typedef typename phoenix::actor<Eval>::nullary_result type;
+    };
+    template <typename Eval>
+    struct result_of<phoenix::actor<Eval> const()>
+        : result_of<phoenix::actor<Eval>()>
+    {};
+}
+namespace boost { namespace phoenix
+{
+    template <typename T>
+    struct as_actor_base;
+    template <typename Base>
+    struct as_actor_base<actor<Base> >
+    {
+        typedef Base type;
+        static Base const&
+        convert(actor<Base> const& x)
+        {
+            return x;
+        }
+    };
+    template <>
+    struct as_actor_base<fusion::void_>
+    {
+        typedef fusion::void_ type;
+        struct error_attempting_to_convert_void_type_to_an_actor {};
+        static void
+        convert(error_attempting_to_convert_void_type_to_an_actor);
+    };
+    template <>
+    struct as_actor_base<void>
+    {
+        typedef void type;
+        struct error_attempting_to_convert_void_type_to_an_actor {};
+        static void
+        convert(error_attempting_to_convert_void_type_to_an_actor);
+    };
+    template <typename T>
+    struct as_actor
+    {
+        typedef actor<typename as_actor_base<T>::type> type;
+        static type
+        convert(T const& x)
+        {
+            return as_actor_base<T>::convert(x);
+        }
+    };
+}}
+namespace boost { namespace phoenix
+{
+    template <typename T>
+    struct is_actor : mpl::false_ {};
+    template <typename Base>
+    struct is_actor<actor<Base> > : mpl::true_ {};
+}}
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        template <typename Arg>
+        struct error_argument_not_found {};
+        inline void test_invalid_argument(int) {}
+    }
+    template <int N>
+    struct argument
+    {
+        typedef mpl::true_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                fusion::result_of::at<typename Env::tie_type, mpl::int_<N> >::type
+            type;
+        };
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename
+                mpl::if_<
+                    mpl::less<mpl::int_<N>, mpl::size<typename Env::args_type> >
+                  , int
+                  , detail::error_argument_not_found<argument<N> >
+                >::type
+            check_out_of_bounds;
+            detail::test_invalid_argument(check_out_of_bounds());
+            return fusion::at_c<N>(env.args());
+        }
+    };
+    namespace arg_names
+    {
+        typedef actor<argument<0> > arg1_type;
+        actor<argument<0> > const arg1 = argument<0>();
+        typedef actor<argument<1> > arg2_type;
+        actor<argument<1> > const arg2 = argument<1>();
+        typedef actor<argument<2> > arg3_type;
+        actor<argument<2> > const arg3 = argument<2>();
+        typedef actor<argument<0> > _1_type;
+        actor<argument<0> > const _1 = argument<0>();
+        typedef actor<argument<1> > _2_type;
+        actor<argument<1> > const _2 = argument<1>();
+        typedef actor<argument<2> > _3_type;
+        actor<argument<2> > const _3 = argument<2>();
+ typedef actor<argument<3> > arg4_type; actor<argument<3> > const arg4 = argument<3>(); typedef actor<argument<3> > _4_type; actor<argument<3> > const _4 = argument<3>(); typedef actor<argument<4> > arg5_type; actor<argument<4> > const arg5 = argument<4>(); typedef actor<argument<4> > _5_type; actor<argument<4> > const _5 = argument<4>(); typedef actor<argument<5> > arg6_type; actor<argument<5> > const arg6 = argument<5>(); typedef actor<argument<5> > _6_type; actor<argument<5> > const _6 = argument<5>(); typedef actor<argument<6> > arg7_type; actor<argument<6> > const arg7 = argument<6>(); typedef actor<argument<6> > _7_type; actor<argument<6> > const _7 = argument<6>(); typedef actor<argument<7> > arg8_type; actor<argument<7> > const arg8 = argument<7>(); typedef actor<argument<7> > _8_type; actor<argument<7> > const _8 = argument<7>(); typedef actor<argument<8> > arg9_type; actor<argument<8> > const arg9 = argument<8>(); typedef actor<argument<8> > _9_type; actor<argument<8> > const _9 = argument<8>(); typedef actor<argument<9> > arg10_type; actor<argument<9> > const arg10 = argument<9>(); typedef actor<argument<9> > _10_type; actor<argument<9> > const _10 = argument<9>();
+    }
+}}
+namespace boost {
+template< typename T > struct remove_pointer { public: typedef T type; };
+template< typename T > struct remove_pointer<T*> { public: typedef T type; };
+template< typename T > struct remove_pointer<T* const> { public: typedef T type; };
+template< typename T > struct remove_pointer<T* volatile> { public: typedef T type; };
+template< typename T > struct remove_pointer<T* const volatile> { public: typedef T type; };
+}
+namespace boost { namespace phoenix
+{
+    namespace meta
+    {
+        template<typename T>
+        struct const_ref
+            : add_reference<typename add_const<T>::type>
+        {};
+        template<typename T>
+        struct argument_type
+            : mpl::eval_if<
+            is_function<typename remove_pointer<T>::type>,
+            mpl::identity<T>,
+            const_ref<T> >
+        {
+            typedef T type;
+        };
+    }
+    template <typename T>
+    struct value
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((mpl::not_<is_reference<T> >::value != 0) == 0 ? false : true) >)>
+ boost_static_assert_typedef_50;
+        typedef mpl::false_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef T type;
+        };
+        value()
+            : val() {}
+        value(T const& arg)
+            : val(arg) {}
+        template <typename Env>
+        T const&
+        eval(Env const&) const
+        {
+            return val;
+        }
+        T val;
+    };
+    template <typename Actor>
+    struct actor_value
+    {
+        typedef typename Actor::no_nullary no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename eval_result<Actor, Env>::type
+                >::type
+            type;
+        };
+        actor_value(Actor const& actor)
+            : actor(actor) {}
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return actor.eval(env);
+        }
+        Actor actor;
+    };
+    template <typename T>
+    inline typename as_actor<T>::type
+    val(T const& v)
+    {
+        return as_actor<T>::convert(v);
+    }
+    template <typename Derived>
+    inline actor<actor_value<Derived> >
+    val(actor<Derived> const& actor)
+    {
+        return actor_value<Derived>(actor);
+    }
+    template <typename T>
+    struct as_actor_base
+    {
+        typedef value<T> type;
+        static value<T>
+        convert(typename meta::argument_type<T>::type x)
+        {
+            return value<T>(x);
+        }
+    };
+    template <typename T>
+    struct as_actor_base<T&>
+    {
+        typedef value<T> type;
+        static value<T>
+        convert(T& x)
+        {
+            return value<T>(x);
+        }
+    };
+    template <typename T, int N>
+    struct as_actor_base<T[N]>
+    {
+        typedef value<T const*> type;
+        static value<T const*>
+        convert(T const x[N])
+        {
+            return value<T const*>(x);
+        }
+    };
+}}
+namespace boost { namespace phoenix
+{
+    template <typename T>
+    struct reference
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((mpl::not_<is_reference<T> >::value != 0) == 0 ? false : true) >)>
+ boost_static_assert_typedef_22;
+        typedef mpl::false_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef T& type;
+        };
+        reference(T& arg)
+            : ref(arg) {}
+        template <typename Env>
+        T& eval(Env const&) const
+        {
+            return ref;
+        }
+        T& ref;
+    private:
+        reference& operator= (reference const&);
+    };
+    template <typename T>
+    inline actor<reference<T> > const
+    ref(T& v)
+    {
+        return reference<T>(v);
+    }
+    template <typename T>
+    inline actor<reference<T const> > const
+    cref(T const& v)
+    {
+        return reference<T const>(v);
+    }
+    namespace detail
+    {
+        struct error_attempting_to_convert_an_actor_to_a_reference {};
+    }
+    template <typename Base>
+    void
+    ref(actor<Base> const& v
+        , detail::error_attempting_to_convert_an_actor_to_a_reference
+            = detail::error_attempting_to_convert_an_actor_to_a_reference());
+    template <typename Base>
+    void
+    cref(actor<Base> const& v
+        , detail::error_attempting_to_convert_an_actor_to_a_reference
+            = detail::error_attempting_to_convert_an_actor_to_a_reference());
+}}
+namespace boost { namespace phoenix
+{
+    namespace detail
+    {
+        template <int N>
+        struct composite_eval;
+        struct compute_no_nullary
+        {
+            template <typename State, typename T>
+            struct apply
+            {
+                typedef typename
+                    mpl::or_<typename T::no_nullary, State>::type
+                type;
+            };
+        };
+    }
+    template <typename EvalPolicy, typename EvalTuple>
+    struct composite : EvalTuple
+    {
+        typedef EvalTuple base_type;
+        typedef composite<EvalPolicy, EvalTuple> self_type;
+        typedef EvalPolicy eval_policy_type;
+        typedef typename
+            mpl::fold<
+                EvalTuple
+              , mpl::false_
+              , detail::compute_no_nullary
+            >::type
+        no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef
+                typename detail::composite_eval<
+                    fusion::result_of::size<base_type>::value>::
+                template result<self_type, Env>::type
+            type;
+        };
+        composite()
+            : base_type() {}
+        composite(base_type const& base)
+            : base_type(base) {}
+        template <typename U0>
+        composite(U0& _0)
+            : base_type(_0) {}
+        template <typename U0, typename U1>
+        composite(U0& _0, U1& _1)
+            : base_type(_0, _1) {}
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            typedef typename result<Env>::type return_type;
+            return detail::
+                composite_eval<fusion::result_of::size<base_type>::value>::template
+                    call<return_type>(*this, env);
+        }
+    template < typename U0 , typename U1 , typename U2>
+    composite( U0 & _0 , U1 & _1 , U2 & _2)
+        : base_type( _0 , _1 , _2) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3)
+        : base_type( _0 , _1 , _2 , _3) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4)
+        : base_type( _0 , _1 , _2 , _3 , _4) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5)
+        : base_type( _0 , _1 , _2 , _3 , _4 , _5) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6)
+        : base_type( _0 , _1 , _2 , _3 , _4 , _5 , _6) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7)
+        : base_type( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7 , U8 & _8)
+        : base_type( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
+    composite( U0 & _0 , U1 & _1 , U2 & _2 , U3 & _3 , U4 & _4 , U5 & _5 , U6 & _6 , U7 & _7 , U8 & _8 , U9 & _9)
+        : base_type( _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
+    };
+    namespace detail
+    {
+        template <int N>
+        struct composite_eval;
+        template <>
+        struct composite_eval<0>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename Composite::eval_policy_type::
+                    template result<Env>::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& , Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(env);
+            }
+        };
+        template <typename Actor, typename Env>
+        struct eval_is_actor
+            : is_actor<typename Actor::template result<Env>::type> {};
+        template <typename Actor, typename Env>
+        struct eval_is_void
+            : is_same<typename Actor::template result<Env>::type, fusion::void_> {};
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<1>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<2>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<3>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<4>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<5>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<6>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4; typedef typename fusion::result_of::value_at_c<Composite, 5>::type actor5;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4 , actor5
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite) , fusion::at_c<5>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<7>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4; typedef typename fusion::result_of::value_at_c<Composite, 5>::type actor5; typedef typename fusion::result_of::value_at_c<Composite, 6>::type actor6;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4 , actor5 , actor6
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite) , fusion::at_c<5>(composite) , fusion::at_c<6>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<8>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4; typedef typename fusion::result_of::value_at_c<Composite, 5>::type actor5; typedef typename fusion::result_of::value_at_c<Composite, 6>::type actor6; typedef typename fusion::result_of::value_at_c<Composite, 7>::type actor7;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4 , actor5 , actor6 , actor7
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite) , fusion::at_c<5>(composite) , fusion::at_c<6>(composite) , fusion::at_c<7>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<9>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4; typedef typename fusion::result_of::value_at_c<Composite, 5>::type actor5; typedef typename fusion::result_of::value_at_c<Composite, 6>::type actor6; typedef typename fusion::result_of::value_at_c<Composite, 7>::type actor7; typedef typename fusion::result_of::value_at_c<Composite, 8>::type actor8;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4 , actor5 , actor6 , actor7 , actor8
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite) , fusion::at_c<5>(composite) , fusion::at_c<6>(composite) , fusion::at_c<7>(composite) , fusion::at_c<8>(composite));
+            }
+        };
+    }
+    namespace detail
+    {
+        template <>
+        struct composite_eval<10>
+        {
+            template <typename Composite, typename Env>
+            struct result
+            {
+                typedef typename fusion::result_of::value_at_c<Composite, 0>::type actor0; typedef typename fusion::result_of::value_at_c<Composite, 1>::type actor1; typedef typename fusion::result_of::value_at_c<Composite, 2>::type actor2; typedef typename fusion::result_of::value_at_c<Composite, 3>::type actor3; typedef typename fusion::result_of::value_at_c<Composite, 4>::type actor4; typedef typename fusion::result_of::value_at_c<Composite, 5>::type actor5; typedef typename fusion::result_of::value_at_c<Composite, 6>::type actor6; typedef typename fusion::result_of::value_at_c<Composite, 7>::type actor7; typedef typename fusion::result_of::value_at_c<Composite, 8>::type actor8; typedef typename fusion::result_of::value_at_c<Composite, 9>::type actor9;
+                typedef typename
+                    Composite::eval_policy_type::template result<
+                        Env, actor0 , actor1 , actor2 , actor3 , actor4 , actor5 , actor6 , actor7 , actor8 , actor9
+                    >::type
+                type;
+            };
+            template <typename RT, typename Composite, typename Env>
+            static RT
+            call(Composite const& composite, Env const& env)
+            {
+                typedef typename Composite::eval_policy_type eval_policy_type;
+                return eval_policy_type::template eval<RT>(
+                    env, fusion::at_c<0>(composite) , fusion::at_c<1>(composite) , fusion::at_c<2>(composite) , fusion::at_c<3>(composite) , fusion::at_c<4>(composite) , fusion::at_c<5>(composite) , fusion::at_c<6>(composite) , fusion::at_c<7>(composite) , fusion::at_c<8>(composite) , fusion::at_c<9>(composite));
+            }
+        };
+    }
+}}
+namespace boost { namespace phoenix
+{
+    template <
+        typename EvalPolicy
+      ,
+ typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ >
+    struct as_composite
+    {
+        typedef composite<
+            EvalPolicy
+          , fusion::vector<
+                typename mpl::eval_if< is_same<T0, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T0> >::type , typename mpl::eval_if< is_same<T1, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T1> >::type , typename mpl::eval_if< is_same<T2, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T2> >::type , typename mpl::eval_if< is_same<T3, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T3> >::type , typename mpl::eval_if< is_same<T4, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T4> >::type , typename mpl::eval_if< is_same<T5, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T5> >::type , typename mpl::eval_if< is_same<T6, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T6> >::type , typename mpl::eval_if< is_same<T7, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T7> >::type , typename mpl::eval_if< is_same<T8, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T8> >::type , typename mpl::eval_if< is_same<T9, fusion::void_> , mpl::identity<fusion::void_> , as_actor_base<T9> >::type>
+        >
+        type;
+    };
+    template <typename EvalPolicy>
+    inline actor<typename as_composite<EvalPolicy>::type>
+    compose()
+    {
+        return actor<typename as_composite<EvalPolicy>::type>();
+    }
+    template <typename EvalPolicy, typename T0>
+    inline actor<typename as_composite<EvalPolicy, T0>::type>
+    compose(T0 const& _0)
+    {
+        return actor<typename as_composite<EvalPolicy, T0>::type>(
+            as_actor<T0>::convert(_0)
+        );
+    }
+    template <typename EvalPolicy, typename T0, typename T1>
+    inline actor<typename as_composite<EvalPolicy, T0, T1>::type>
+    compose(T0 const& _0, T1 const& _1)
+    {
+        return actor<typename as_composite<EvalPolicy, T0, T1>::type>(
+            as_actor<T0>::convert(_0)
+          , as_actor<T1>::convert(_1)
+        );
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4) , as_actor<T5>::convert(_5));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4) , as_actor<T5>::convert(_5) , as_actor<T6>::convert(_6));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4) , as_actor<T5>::convert(_5) , as_actor<T6>::convert(_6) , as_actor<T7>::convert(_7));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4) , as_actor<T5>::convert(_5) , as_actor<T6>::convert(_6) , as_actor<T7>::convert(_7) , as_actor<T8>::convert(_8));
+    }
+    template <typename EvalPolicy, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    inline actor<
+        typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::type>
+    compose( T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8 , T9 const& _9)
+    {
+        return actor<
+            typename as_composite<EvalPolicy, T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::type>(
+                as_actor<T0>::convert(_0) , as_actor<T1>::convert(_1) , as_actor<T2>::convert(_2) , as_actor<T3>::convert(_3) , as_actor<T4>::convert(_4) , as_actor<T5>::convert(_5) , as_actor<T6>::convert(_6) , as_actor<T7>::convert(_7) , as_actor<T8>::convert(_8) , as_actor<T9>::convert(_9));
+    }
+    template <
+        typename EvalPolicy
+      ,
+ typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ >
+    struct re_curry
+    {
+        typedef actor<
+            typename as_composite<
+                EvalPolicy
+              , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>::type
+            >
+        type;
+    };
+}}
+namespace boost { namespace phoenix
+{
+    struct null_actor
+    {
+        typedef mpl::false_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef void type;
+        };
+        template <typename Env>
+        void
+        eval(Env const&) const
+        {
+        }
+    };
+    actor<null_actor> const nothing = null_actor();
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename T>
+    struct as_meta_element
+      : mpl::eval_if_c<is_abstract<T>::value || is_function<T>::value
+          , add_reference<T>, remove_const<T> >
+    {};
+    template <typename T>
+    struct as_meta_element<T&> : as_meta_element<T>
+    {};
+    template <typename T, int N>
+    struct as_meta_element<T[N]>
+    {
+        typedef const T(&type)[N];
+    };
+    namespace result_of
+    {
+        template <typename Car, typename Cdr = fusion::nil>
+        struct make_cons
+        {
+            typedef typename as_meta_element<Car>::type car_type;
+            typedef typename fusion::cons<car_type, Cdr> type;
+        };
+    }
+    template <typename Car, typename Cdr>
+    fusion::cons<typename as_meta_element<Car>::type, Cdr>
+    make_cons(Car const& car, Cdr const& cdr)
+    {
+        typedef typename as_meta_element<Car>::type car_type;
+        typedef typename fusion::cons<car_type, Cdr> result;
+        return result(car, cdr);
+    }
+    template <typename Car>
+    fusion::cons<typename as_meta_element<Car>::type>
+    make_cons(Car const& car)
+    {
+        typedef typename as_meta_element<Car>::type car_type;
+        typedef typename fusion::cons<car_type> result;
+        return result(car);
+    }
+}}}
+namespace boost { namespace spirit
+{
+    struct unused_type
+    {
+        unused_type()
+        {
+        }
+        template <typename T>
+        unused_type(T const&)
+        {
+        }
+        template <typename T>
+        unused_type const&
+        operator=(T const&) const
+        {
+            return *this;
+        }
+        template <typename T>
+        unused_type&
+        operator=(T const&)
+        {
+            return *this;
+        }
+        unused_type const&
+        operator=(unused_type const&) const
+        {
+            return *this;
+        }
+        unused_type&
+        operator=(unused_type const&)
+        {
+            return *this;
+        }
+    };
+    unused_type const unused = unused_type();
+    namespace detail
+    {
+        struct unused_only
+        {
+            unused_only(unused_type const&) {}
+        };
+    }
+    template <typename Out>
+    inline Out& operator<<(Out& out, detail::unused_only const&)
+    {
+        return out;
+    }
+    template <typename In>
+    inline In& operator>>(In& in, unused_type&)
+    {
+        return in;
+    }
+    namespace traits
+    {
+        template <typename T> struct not_is_unused : mpl::true_ {};
+        template <> struct not_is_unused<unused_type> : mpl::false_ {};
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <typename Domain, typename T, typename Enable = void>
+    struct is_modifier_directive;
+    template <typename Modifiers, typename T>
+    struct has_modifier
+        : is_base_of<T, Modifiers> {};
+    template <typename Current, typename New, typename Enable = void>
+    struct compound_modifier : Current, New
+    {
+        compound_modifier()
+          : Current(), New() {}
+        compound_modifier(Current const& current, New const& new_)
+          : Current(current), New(new_) {}
+    };
+    template <typename Current, typename New>
+    struct compound_modifier<
+        Current, New, typename enable_if<has_modifier<Current, New> >::type>
+      : Current
+    {
+        compound_modifier()
+          : Current() {}
+        compound_modifier(Current const& current, New const&)
+          : Current(current) {}
+    };
+    template <typename New, typename Enable>
+    struct compound_modifier<unused_type, New, Enable> : New
+    {
+        compound_modifier()
+          : New() {}
+        compound_modifier(unused_type, New const& new_)
+          : New(new_) {}
+    };
+    template <typename Domain, typename Enable = void>
+    struct modify
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Tag, typename Modifiers>
+        struct result<This(Tag, Modifiers)>
+        {
+            typedef typename remove_const<
+                typename remove_reference<Tag>::type>::type
+            tag_type;
+            typedef typename remove_const<
+                typename remove_reference<Modifiers>::type>::type
+            modifiers_type;
+            typedef typename mpl::if_<
+                is_modifier_directive<Domain, tag_type>
+              , compound_modifier<modifiers_type, tag_type>
+              , Modifiers>::type
+            type;
+        };
+        template <typename Tag, typename Modifiers>
+        typename result<modify(Tag, Modifiers)>::type
+        operator()(Tag tag, Modifiers modifiers) const
+        {
+            return op(tag, modifiers, is_modifier_directive<Domain, Tag>());
+        }
+        template <typename Tag, typename Modifiers>
+        Modifiers
+        op(Tag , Modifiers modifiers, mpl::false_) const
+        {
+            return modifiers;
+        }
+        template <typename Tag, typename Modifiers>
+        compound_modifier<Modifiers, Tag>
+        op(Tag tag, Modifiers modifiers, mpl::true_) const
+        {
+            return compound_modifier<Modifiers, Tag>(modifiers, tag);
+        }
+    };
+}}
+namespace boost { namespace proto
+{
+    template <typename Domain, typename Enable>
+    struct is_callable<spirit::modify<Domain, Enable> >
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit
+{
+    template <typename Domain, typename Tag, typename Enable = void>
+    struct make_component
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>;
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const;
+    };
+    namespace tag
+    {
+        struct directive;
+        struct action;
+    }
+    template <typename Domain, typename T, typename Enable = void>
+    struct flatten_tree;
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl
+      : proto::transform_impl<Expr, State, Data>
+    {
+        typedef typename
+            proto::result_of::value<Expr>::type
+        value;
+        typedef typename result_of::make_cons<value>::type elements;
+        typedef
+            make_component<Domain, proto::tag::terminal>
+        make_component_;
+        typedef typename
+            make_component_::template
+                result<make_component_(elements, Data)>::type
+        result_type;
+        result_type operator()(
+            typename make_terminal_impl::expr_param expr
+          , typename make_terminal_impl::state_param
+          , typename make_terminal_impl::data_param data
+        ) const
+        {
+            return typename make_terminal_impl::make_component_()(
+                detail::make_cons(proto::value(expr))
+              , data
+            );
+        }
+    };
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+      : proto::transform_impl<phoenix::actor<Expr>, State, Data>
+    {
+        typedef phoenix::actor<Expr> value;
+        typedef typename result_of::make_cons<value>::type elements;
+        typedef make_component<Domain, proto::tag::terminal> make_component_;
+        typedef typename
+            make_component_::template
+                result<make_component_(elements, Data)>::type
+        result_type;
+        result_type operator()(
+            typename make_terminal_impl::expr_param expr
+          , typename make_terminal_impl::state_param
+          , typename make_terminal_impl::data_param data
+        ) const
+        {
+            return typename make_terminal_impl::make_component_()(
+                detail::make_cons(expr)
+              , data
+            );
+        }
+    };
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr> &, State, Data, Domain>
+        : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+    {};
+    template <typename Expr, typename State, typename Data, typename Domain>
+    struct make_terminal_impl<phoenix::actor<Expr> const &, State, Data, Domain>
+        : make_terminal_impl<phoenix::actor<Expr>, State, Data, Domain>
+    {};
+    template <typename Domain>
+    struct make_terminal : proto::transform<make_terminal<Domain> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : make_terminal_impl<Expr, State, Data, Domain> {};
+    };
+    template <typename Domain, typename Tag, typename Grammar>
+    struct make_unary : proto::transform<make_unary<Domain, Tag, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::result_of::child_c<Expr, 0>::type
+            child;
+            typedef typename Grammar::
+                template result<Grammar(child, State, Data)>::type
+            child_component;
+            typedef typename
+                result_of::make_cons<child_component>::type
+            elements;
+            typedef make_component<Domain, Tag> make_component_;
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements, Data)>::type
+            result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return typename impl::make_component_()(
+                    detail::make_cons(
+                        Grammar()(proto::child(expr), state, data))
+                  , data
+                );
+            }
+        };
+    };
+    template <typename Domain, typename Tag, typename Grammar,
+        bool flatten = flatten_tree<Domain, Tag>::value>
+    struct make_binary
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 0>::type
+                  , State, Data)>::type
+            lhs_component;
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 1>::type
+                  , State, Data)>::type
+            rhs_component;
+            typedef typename
+                result_of::make_cons<
+                    lhs_component
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+            typedef make_component<Domain, Tag> make_component_;
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)
+                      , detail::make_cons(
+                            Grammar()(
+                                proto::child_c<1>(expr), state, data)
+                        )
+                    );
+                return make_component_()(elements, data);
+            }
+        };
+    };
+    template <typename Grammar>
+    struct make_binary_helper : proto::transform<make_binary_helper<Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(Expr, State, Data)>::type
+            lhs;
+            typedef typename result_of::make_cons<lhs, State>::type result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return detail::make_cons(Grammar()(expr, state, data), state);
+            }
+        };
+    };
+    template <typename Domain, typename Tag, typename Grammar>
+    struct make_binary<Domain, Tag, Grammar, true>
+      : proto::transform<make_binary<Domain, Tag, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::reverse_fold_tree<
+                    proto::_
+                  , proto::make<fusion::nil>
+                  , make_binary_helper<Grammar>
+                >::template impl<Expr, State, Data>
+            reverse_fold_tree;
+            typedef typename reverse_fold_tree::result_type elements;
+            typedef make_component<Domain, Tag> make_component_;
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements, Data)>::type
+            result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                return make_component_()(
+                    reverse_fold_tree()(expr, state, data), data);
+            }
+        };
+    };
+    template <typename Domain, typename Grammar>
+    struct make_directive : proto::transform<make_directive<Domain, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename
+                proto::result_of::child_c<Expr, 0>::type
+            lhs;
+            typedef typename
+                proto::result_of::value<lhs>::type
+            tag_type;
+            typedef typename modify<Domain>::
+                template result<modify<Domain>(tag_type, Data)>::type
+            modifier_type;
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 1>::type
+                  , State
+                  , modifier_type
+                )>::type
+            rhs_component;
+            typedef typename
+                result_of::make_cons<
+                    tag_type
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+            typedef make_component<Domain, tag::directive> make_component_;
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                tag_type tag = proto::value(proto::child_c<0>(expr));
+                typename remove_reference<modifier_type>::type
+                    modifier = modify<Domain>()(tag, data);
+                elements_type elements =
+                    detail::make_cons(
+                        tag
+                      , detail::make_cons(
+                            Grammar()(
+                                proto::child_c<1>(expr)
+                              , state, modifier)
+                        )
+                    );
+                return make_component_()(elements, data);
+            }
+        };
+    };
+    template <typename Domain, typename Grammar>
+    struct make_action : proto::transform<make_action<Domain, Grammar> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename Grammar::
+                template result<Grammar(
+                    typename proto::result_of::child_c<Expr, 0>::type
+                  , State
+                  , Data
+                )>::type
+            lhs_component;
+            typedef typename
+                proto::result_of::value<
+                    typename proto::result_of::child_c<Expr, 1>::type
+                >::type
+            rhs_component;
+            typedef typename
+                result_of::make_cons<
+                    lhs_component
+                  , typename result_of::make_cons<rhs_component>::type
+                >::type
+            elements_type;
+            typedef make_component<Domain, tag::action> make_component_;
+            typedef typename
+                make_component_::template
+                    result<make_component_(elements_type, Data)>::type
+            result_type;
+            result_type operator()(
+                typename impl::expr_param expr
+              , typename impl::state_param state
+              , typename impl::data_param data
+            ) const
+            {
+                elements_type elements =
+                    detail::make_cons(
+                        Grammar()(
+                            proto::child_c<0>(expr), state, data)
+                      , detail::make_cons(
+                            proto::value(proto::child_c<1>(expr)))
+                    );
+                return make_component_()(elements, data);
+            }
+        };
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Domain, typename Tag, typename Enable = void>
+    struct use_operator : mpl::false_ {};
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_function : mpl::false_ {};
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_directive : mpl::false_ {};
+    template <typename Domain, typename T, typename Enable >
+    struct is_modifier_directive : mpl::false_ {};
+    template <typename Domain, typename T, typename Enable = void>
+    struct use_terminal : mpl::false_ {};
+    template <typename Domain, typename T, typename Enable >
+    struct flatten_tree : mpl::false_ {};
+    template <typename Domain>
+    struct meta_compiler
+    {
+        struct meta_grammar;
+        struct error_proto_tag_subscript_cannot_be_used; typedef struct
+ error_proto_tag_subscript_cannot_be_used60
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (error_proto_tag_subscript_cannot_be_used::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg60
+        ; enum { mpl_assertion_in_line_60 = sizeof( boost::mpl::assertion_failed<(( !use_operator<Domain, proto::tag::subscript>::value ))>( mpl_assert_arg60::assert_arg() ) ) }
+                                                        ;
+        struct cases
+        {
+            template <typename Tag, typename Enable = void>
+            struct case_
+              : proto::not_<proto::_>
+            {};
+            template <typename Enable>
+            struct case_<proto::tag::terminal, Enable>
+              : proto::when<
+                    proto::if_<use_terminal<Domain, proto::_value>()>,
+                    detail::make_terminal<Domain>
+                >
+            {};
+            template <typename Tag>
+            struct case_<Tag, typename enable_if<use_operator<Domain, Tag> >::type>
+              : proto::or_<
+                    proto::when<proto::binary_expr<Tag, meta_grammar, meta_grammar>,
+                        detail::make_binary<Domain, Tag, meta_grammar>
+                    >,
+                    proto::when<proto::unary_expr<Tag, meta_grammar>,
+                        detail::make_unary<Domain, Tag, meta_grammar>
+                    >
+                >
+            {};
+            template <typename Enable>
+            struct case_<proto::tag::subscript, Enable>
+              : proto::or_<
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , proto::and_<
+                            proto::terminal<proto::_>
+                          , proto::if_<use_directive<Domain, proto::_value >()> >
+                      , meta_grammar>,
+                        detail::make_directive<Domain, meta_grammar>
+                    >,
+                    proto::when<proto::binary_expr<proto::tag::subscript
+                      , meta_grammar, proto::_>,
+                        detail::make_action<Domain, meta_grammar>
+                    >
+                >
+            {};
+        };
+        struct meta_grammar
+          : proto::switch_<cases>
+        {};
+    };
+    namespace result_of
+    {
+        template <typename Domain, typename Expr
+          , typename Modifiers = unused_type, typename Enable = void>
+        struct compile
+        {
+            typedef typename meta_compiler<Domain>::meta_grammar meta_grammar;
+            typedef typename meta_grammar::
+                template result<meta_grammar(Expr, mpl::void_, Modifiers)>::type
+            type;
+        };
+        template <typename Domain, typename Expr, typename Modifiers>
+        struct compile<Domain, Expr, Modifiers,
+            typename disable_if<proto::is_expr<Expr> >::type>
+          : compile<Domain, typename proto::terminal<Expr>::type, Modifiers> {};
+    }
+    namespace traits
+    {
+        template <typename Domain, typename Expr>
+        struct matches :
+            proto::matches<
+                typename proto::result_of::as_expr<
+                    typename remove_reference<Expr>::type>::type,
+                typename meta_compiler<Domain>::meta_grammar
+            >
+        {
+        };
+    }
+    namespace detail
+    {
+        template <typename Domain>
+        struct compiler
+        {
+            template <typename Expr, typename Modifiers>
+            static typename spirit::result_of::compile<Domain, Expr, Modifiers>::type
+            compile(Expr const& expr, Modifiers modifiers, mpl::true_)
+            {
+                typename meta_compiler<Domain>::meta_grammar compiler;
+                return compiler(expr, mpl::void_(), modifiers);
+            }
+            template <typename Expr, typename Modifiers>
+            static typename spirit::result_of::compile<Domain, Expr, Modifiers>::type
+            compile(Expr const& expr, Modifiers modifiers, mpl::false_)
+            {
+                typename meta_compiler<Domain>::meta_grammar compiler;
+                typedef typename detail::as_meta_element<Expr>::type expr_;
+                typename proto::terminal<expr_>::type term = {expr};
+                return compiler(term, mpl::void_(), modifiers);
+            }
+        };
+    }
+    template <typename Domain, typename Expr>
+    inline typename result_of::compile<Domain, Expr, unused_type>::type
+    compile(Expr const& expr)
+    {
+        typedef typename proto::is_expr<Expr>::type is_expr;
+        return detail::compiler<Domain>::compile(expr, unused, is_expr());
+    }
+    template <typename Domain, typename Expr, typename Modifiers>
+    inline typename result_of::compile<Domain, Expr, Modifiers>::type
+    compile(Expr const& expr, Modifiers modifiers)
+    {
+        typedef typename proto::is_expr<Expr>::type is_expr;
+        return detail::compiler<Domain>::compile(expr, modifiers, is_expr());
+    }
+    template <typename Elements, template <typename Subject> class generator>
+    struct make_unary_composite
+    {
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 0>::type
+        element_type;
+        typedef generator<element_type> result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(elements));
+        }
+    };
+    template <typename Elements, template <typename Left, typename Right> class generator>
+    struct make_binary_composite
+    {
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 0>::type
+        left_type;
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 1>::type
+        right_type;
+        typedef generator<left_type, right_type> result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(elements)
+              , fusion::at_c<1>(elements)
+            );
+        }
+    };
+    template <typename Elements, template <typename Elements_> class generator>
+    struct make_nary_composite
+    {
+        typedef generator<Elements> result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return result_type(elements);
+        }
+    };
+}}
+namespace boost {
+namespace detail { namespace variant {
+template <
+      typename T, typename Dest, typename Source
+      , typename Arity = mpl::int_< mpl::aux::template_arity<T>::value >
+    >
+struct substitute;
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+struct void_;
+template <typename T>
+struct convert_void
+{
+    typedef T type;
+};
+template <>
+struct convert_void< void_ >
+{
+    typedef mpl::na type;
+};
+}}
+template < typename T0 = detail::variant::void_ , typename T1 = detail::variant::void_ , typename T2 = detail::variant::void_ , typename T3 = detail::variant::void_ , typename T4 = detail::variant::void_ , typename T5 = detail::variant::void_ , typename T6 = detail::variant::void_ , typename T7 = detail::variant::void_ , typename T8 = detail::variant::void_ , typename T9 = detail::variant::void_ , typename T10 = detail::variant::void_ , typename T11 = detail::variant::void_ , typename T12 = detail::variant::void_ , typename T13 = detail::variant::void_ , typename T14 = detail::variant::void_ , typename T15 = detail::variant::void_ , typename T16 = detail::variant::void_ , typename T17 = detail::variant::void_ , typename T18 = detail::variant::void_ , typename T19 = detail::variant::void_ > class variant;
+template < typename T0 = detail::variant::void_ , typename T1 = detail::variant::void_ , typename T2 = detail::variant::void_ , typename T3 = detail::variant::void_ , typename T4 = detail::variant::void_ , typename T5 = detail::variant::void_ , typename T6 = detail::variant::void_ , typename T7 = detail::variant::void_ , typename T8 = detail::variant::void_ , typename T9 = detail::variant::void_ , typename T10 = detail::variant::void_ , typename T11 = detail::variant::void_ , typename T12 = detail::variant::void_ , typename T13 = detail::variant::void_ , typename T14 = detail::variant::void_ , typename T15 = detail::variant::void_ , typename T16 = detail::variant::void_ , typename T17 = detail::variant::void_ , typename T18 = detail::variant::void_ , typename T19 = detail::variant::void_ > struct make_recursive_variant;
+    struct recursive_variant_ {};
+template <typename Types> struct make_variant_over;
+template <typename Types> struct make_recursive_variant_over;
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+class backup_holder
+{
+private:
+    T* backup_;
+public:
+    ~backup_holder()
+    {
+        delete backup_;
+    }
+    explicit backup_holder(T* backup)
+        : backup_(backup)
+    {
+    }
+    backup_holder(const backup_holder&);
+public:
+    backup_holder& operator=(const backup_holder& rhs)
+    {
+        *backup_ = rhs.get();
+        return *this;
+    }
+    backup_holder& operator=(const T& rhs)
+    {
+        *backup_ = rhs;
+        return *this;
+    }
+    void swap(backup_holder& rhs)
+    {
+        T* tmp = rhs.backup_;
+        rhs.backup_ = this->backup_;
+        this->backup_ = tmp;
+    }
+public:
+    T& get()
+    {
+        return *backup_;
+    }
+    const T& get() const
+    {
+        return *backup_;
+    }
+};
+template <typename T>
+backup_holder<T>::backup_holder(const backup_holder&)
+    : backup_(0)
+{
+    (static_cast<void> (0));
+}
+template <typename T>
+void swap(backup_holder<T>& lhs, backup_holder<T>& rhs)
+{
+    lhs.swap(rhs);
+}
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+struct recursive_flag
+{
+    typedef T type;
+};
+template <typename T>
+struct is_recursive_flag
+    : mpl::false_
+{
+};
+template <typename T>
+struct is_recursive_flag< recursive_flag<T> >
+    : mpl::true_
+{
+};
+template <
+      typename T
+    , typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct enable_recursive;
+template <
+      typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct quoted_enable_recursive;
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+inline T forced_return( )
+{
+    (static_cast<void> (0));
+    typedef typename boost::remove_reference<T>::type basic_type;
+    basic_type* dummy = 0;
+    return *static_cast< basic_type* >(dummy);
+}
+template <>
+inline void forced_return<void>( )
+{
+    (static_cast<void> (0));
+}
+}}
+}
+namespace boost{
+namespace detail{
+template <typename T, bool small_>
+struct ct_imp2
+{
+   typedef const T& param_type;
+};
+template <typename T>
+struct ct_imp2<T, true>
+{
+   typedef const T param_type;
+};
+template <typename T, bool isp, bool b1>
+struct ct_imp
+{
+   typedef const T& param_type;
+};
+template <typename T, bool isp>
+struct ct_imp<T, isp, true>
+{
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+template <typename T, bool b1>
+struct ct_imp<T, true, b1>
+{
+   typedef const T param_type;
+};
+}
+template <typename T>
+struct call_traits
+{
+public:
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef typename boost::detail::ct_imp<
+      T,
+      ::boost::is_pointer<T>::value,
+      ::boost::is_arithmetic<T>::value
+   >::param_type param_type;
+};
+template <typename T>
+struct call_traits<T&>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;
+};
+template <typename T, std::size_t N>
+struct call_traits<T [N]>
+{
+private:
+   typedef T array_type[N];
+public:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+template <typename T, std::size_t N>
+struct call_traits<const T [N]>
+{
+private:
+   typedef const T array_type[N];
+public:
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct has_nothrow_copy_imp{
+   static const bool value = ((__has_nothrow_copy(T) ) && !is_volatile<T>::value && !is_reference<T>::value);
+};
+}
+template< typename T > struct has_nothrow_copy : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { public: };
+template< typename T > struct has_nothrow_copy_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { public: };
+template<> struct has_nothrow_copy< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_copy_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+template <typename RefT>
+class reference_content
+{
+private:
+    RefT content_;
+public:
+    ~reference_content()
+    {
+    }
+    reference_content(RefT r)
+        : content_( r )
+    {
+    }
+    reference_content(const reference_content& operand)
+        : content_( operand.content_ )
+    {
+    }
+private:
+    reference_content& operator=(const reference_content&);
+public:
+    RefT get() const
+    {
+        return content_;
+    }
+};
+template <typename T = mpl::void_> struct make_reference_content;
+template <typename T>
+struct make_reference_content
+{
+    typedef T type;
+};
+template <typename T>
+struct make_reference_content< T& >
+{
+    typedef reference_content<T&> type;
+};
+template <>
+struct make_reference_content< mpl::void_ >
+{
+    template <typename T>
+    struct apply
+        : make_reference_content<T>
+    {
+    };
+    typedef mpl::void_ type;
+};
+}
+template <typename T>
+struct has_nothrow_copy<
+      ::boost::detail::reference_content< T& >
+    >
+    : mpl::true_
+{
+};
+}
+namespace boost {
+template <typename T> class recursive_wrapper;
+namespace detail {
+template <typename T>
+struct is_recursive_wrapper_impl
+    : mpl::false_
+{
+};
+template <typename T>
+struct is_recursive_wrapper_impl< recursive_wrapper<T> >
+    : mpl::true_
+{
+};
+}
+template< typename T > struct is_recursive_wrapper : public ::boost::integral_constant<bool,(::boost::detail::is_recursive_wrapper_impl<T>::value)> { public: };
+template <typename T>
+struct unwrap_recursive
+{
+    typedef T type;
+};
+template <typename T>
+struct unwrap_recursive< recursive_wrapper<T> >
+{
+    typedef T type;
+};
+}
+namespace boost {
+namespace detail { namespace variant {
+struct make_initializer_node
+{
+    template <typename BaseIndexPair, typename Iterator>
+    struct apply
+    {
+    private:
+        typedef typename BaseIndexPair::first
+            base;
+        typedef typename BaseIndexPair::second
+            index;
+        class initializer_node
+            : public base
+        {
+        private:
+            typedef typename mpl::deref<Iterator>::type
+                recursive_enabled_T;
+            typedef typename unwrap_recursive<recursive_enabled_T>::type
+                public_T;
+            typedef typename call_traits<public_T>::param_type
+                param_T;
+        public:
+            using base::initialize;
+            static int initialize(void* dest, param_T operand)
+            {
+                typedef typename boost::detail::make_reference_content<
+                      recursive_enabled_T
+                    >::type internal_T;
+                new(dest) internal_T(operand);
+                return index::value;
+            }
+        };
+        friend class initializer_node;
+    public:
+        typedef mpl::pair<
+              initializer_node
+            , typename mpl::next< index >::type
+            > type;
+    };
+};
+class initializer_root
+{
+public:
+    static void initialize();
+};
+}}
+}
+namespace boost { namespace mpl { namespace aux {
+struct list_tag;
+struct l_iter_tag;
+}}}
+namespace boost { namespace mpl {
+template<
+      typename Size
+    , typename T
+    , typename Next
+    >
+struct l_item
+{
+    typedef aux::list_tag tag;
+    typedef l_item type;
+    typedef Size size;
+    typedef T item;
+    typedef Next next;
+};
+struct l_end
+{
+    typedef aux::list_tag tag;
+    typedef l_end type;
+    typedef long_<0> size;
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct push_front_impl< aux::list_tag >
+{
+    template< typename List, typename T > struct apply
+    {
+        typedef l_item<
+              typename next<typename List::size>::type
+            , T
+            , typename List::type
+            > type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct pop_front_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+    {
+        typedef typename mpl::next<List>::type type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Tag > struct has_push_back_impl;
+template<>
+struct has_push_back_impl< aux::list_tag >
+{
+    template< typename Seq > struct apply
+        : false_
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct front_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+    {
+        typedef typename List::item type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct clear_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+    {
+        typedef l_end type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct O1_size_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+        : List::size
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct size_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+        : List::size
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<>
+struct empty_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+        : not_<typename List::size>
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Node >
+struct l_iter
+{
+    typedef aux::l_iter_tag tag;
+    typedef forward_iterator_tag category;
+};
+template< typename Node >
+struct deref< l_iter<Node> >
+{
+    typedef typename Node::item type;
+};
+template< typename Node >
+struct next< l_iter<Node> >
+{
+    typedef l_iter< typename Node::next > type;
+};
+template<> struct l_iter<l_end>
+{
+    typedef aux::l_iter_tag tag;
+    typedef forward_iterator_tag category;
+};
+template< typename T1 , typename Tag > struct lambda< l_iter< T1 > , Tag , int_<1> > { typedef false_ is_le; typedef l_iter< T1 > result_; typedef result_ type; };
+}}
+namespace boost { namespace mpl {
+template<>
+struct begin_impl< aux::list_tag >
+{
+    template< typename List > struct apply
+    {
+        typedef l_iter<typename List::type> type;
+    };
+};
+template<>
+struct end_impl< aux::list_tag >
+{
+    template< typename > struct apply
+    {
+        typedef l_iter<l_end> type;
+    };
+};
+}}
+namespace boost { namespace mpl {
+template< typename Dummy = na > struct list0;
+template<> struct list0<na>
+    : l_end
+{
+    typedef l_end type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0
+    >
+struct list1
+    : l_item<
+          long_<1>
+        , T0
+        , l_end
+        >
+{
+    typedef list1 type;
+};
+template<
+      typename T0, typename T1
+    >
+struct list2
+    : l_item<
+          long_<2>
+        , T0
+        , list1<T1>
+        >
+{
+    typedef list2 type;
+};
+template<
+      typename T0, typename T1, typename T2
+    >
+struct list3
+    : l_item<
+          long_<3>
+        , T0
+        , list2< T1,T2 >
+        >
+{
+    typedef list3 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct list4
+    : l_item<
+          long_<4>
+        , T0
+        , list3< T1,T2,T3 >
+        >
+{
+    typedef list4 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct list5
+    : l_item<
+          long_<5>
+        , T0
+        , list4< T1,T2,T3,T4 >
+        >
+{
+    typedef list5 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct list6
+    : l_item<
+          long_<6>
+        , T0
+        , list5< T1,T2,T3,T4,T5 >
+        >
+{
+    typedef list6 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct list7
+    : l_item<
+          long_<7>
+        , T0
+        , list6< T1,T2,T3,T4,T5,T6 >
+        >
+{
+    typedef list7 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct list8
+    : l_item<
+          long_<8>
+        , T0
+        , list7< T1,T2,T3,T4,T5,T6,T7 >
+        >
+{
+    typedef list8 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct list9
+    : l_item<
+          long_<9>
+        , T0
+        , list8< T1,T2,T3,T4,T5,T6,T7,T8 >
+        >
+{
+    typedef list9 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct list10
+    : l_item<
+          long_<10>
+        , T0
+        , list9< T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+        >
+{
+    typedef list10 type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct list11
+    : l_item<
+          long_<11>
+        , T0
+        , list10< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+        >
+{
+    typedef list11 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct list12
+    : l_item<
+          long_<12>
+        , T0
+        , list11< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+        >
+{
+    typedef list12 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct list13
+    : l_item<
+          long_<13>
+        , T0
+        , list12< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+        >
+{
+    typedef list13 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct list14
+    : l_item<
+          long_<14>
+        , T0
+        , list13< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+        >
+{
+    typedef list14 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct list15
+    : l_item<
+          long_<15>
+        , T0
+        , list14< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
+        >
+{
+    typedef list15 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct list16
+    : l_item<
+          long_<16>
+        , T0
+        , list15< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
+        >
+{
+    typedef list16 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct list17
+    : l_item<
+          long_<17>
+        , T0
+        , list16< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
+        >
+{
+    typedef list17 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct list18
+    : l_item<
+          long_<18>
+        , T0
+        , list17< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
+        >
+{
+    typedef list18 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct list19
+    : l_item<
+          long_<19>
+        , T0
+        , list18< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
+        >
+{
+    typedef list19 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct list20
+    : l_item<
+          long_<20>
+        , T0
+        , list19< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >
+        >
+{
+    typedef list20 type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
+    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
+    , typename T12 = na, typename T13 = na, typename T14 = na
+    , typename T15 = na, typename T16 = na, typename T17 = na
+    , typename T18 = na, typename T19 = na
+    >
+struct list;
+template<
+    >
+struct list<
+          na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list0< >
+{
+    typedef list0< >::type type;
+};
+template<
+      typename T0
+    >
+struct list<
+          T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list1<T0>
+{
+    typedef typename list1<T0>::type type;
+};
+template<
+      typename T0, typename T1
+    >
+struct list<
+          T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list2< T0,T1 >
+{
+    typedef typename list2< T0,T1 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2
+    >
+struct list<
+          T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list3< T0,T1,T2 >
+{
+    typedef typename list3< T0,T1,T2 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct list<
+          T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list4< T0,T1,T2,T3 >
+{
+    typedef typename list4< T0,T1,T2,T3 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct list<
+          T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list5< T0,T1,T2,T3,T4 >
+{
+    typedef typename list5< T0,T1,T2,T3,T4 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list6< T0,T1,T2,T3,T4,T5 >
+{
+    typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list7< T0,T1,T2,T3,T4,T5,T6 >
+{
+    typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list8< T0,T1,T2,T3,T4,T5,T6,T7 >
+{
+    typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+{
+    typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+{
+    typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
+        , na, na, na
+        >
+    : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+{
+    typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
+        , na, na, na, na
+        >
+    : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+{
+    typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
+        , na, na, na, na
+        >
+    : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+{
+    typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
+        , na, na, na, na
+        >
+    : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+{
+    typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
+        , na, na, na, na
+        >
+    : list15<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        >
+{
+    typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, na, na, na, na
+        >
+    : list16<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15
+        >
+{
+    typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, na, na, na
+        >
+    : list17<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16
+        >
+{
+    typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, na, na
+        >
+    : list18<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17
+        >
+{
+    typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct list<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, na
+        >
+    : list19<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18
+        >
+{
+    typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct list
+    : list20<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, T19
+        >
+{
+    typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
+};
+}}
+namespace boost {
+namespace detail { namespace variant {
+template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+struct make_variant_list
+{
+public:
+    typedef typename mpl::list<
+ typename convert_void< T0 >::type , typename convert_void< T1 >::type , typename convert_void< T2 >::type , typename convert_void< T3 >::type , typename convert_void< T4 >::type , typename convert_void< T5 >::type , typename convert_void< T6 >::type , typename convert_void< T7 >::type , typename convert_void< T8 >::type , typename convert_void< T9 >::type , typename convert_void< T10 >::type , typename convert_void< T11 >::type , typename convert_void< T12 >::type , typename convert_void< T13 >::type , typename convert_void< T14 >::type , typename convert_void< T15 >::type , typename convert_void< T16 >::type , typename convert_void< T17 >::type , typename convert_void< T18 >::type , typename convert_void< T19 >::type
+        >::type type;
+};
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename Types>
+struct over_sequence
+{
+    typedef Types type;
+};
+template <typename T>
+struct is_over_sequence
+    : mpl::false_
+{
+};
+template <typename Types>
+struct is_over_sequence< over_sequence<Types> >
+    : mpl::true_
+{
+};
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+inline T& cast_storage(
+      void* storage
+    )
+{
+    return *static_cast<T*>(storage);
+}
+template <typename T>
+inline const T& cast_storage(
+      const void* storage
+    )
+{
+    return *static_cast<const T*>(storage);
+}
+}}
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct has_trivial_assign_impl
+{
+   static const bool value = ((__has_trivial_assign(T) ) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value);
+};
+}
+template< typename T > struct has_trivial_assign : public ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { public: };
+template<> struct has_trivial_assign< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_trivial_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+struct has_trivial_move_impl
+{
+    static const bool value = ( ::boost::mpl::and_< has_trivial_copy<T> , has_trivial_assign<T> >::type::value )
+         ;
+};
+template< typename T > struct has_trivial_move : public ::boost::integral_constant<bool,(::boost::detail::variant::has_trivial_move_impl<T>::value)> { };
+template <typename T>
+struct has_trivial_move_constructor_impl
+{
+    static const bool value = ( ::boost::mpl::or_< has_trivial_move<T> , has_trivial_copy<T> >::type::value )
+         ;
+};
+template< typename T > struct has_trivial_move_constructor : public ::boost::integral_constant<bool,(::boost::detail::variant::has_trivial_move_constructor_impl<T>::value)> { };
+template <typename T>
+struct has_trivial_move_assign_impl
+{
+    static const bool value = ( ::boost::mpl::or_< has_trivial_move<T> , has_trivial_assign<T> >::type::value )
+         ;
+};
+template< typename T > struct has_trivial_move_assign : public ::boost::integral_constant<bool,(::boost::detail::variant::has_trivial_move_assign_impl<T>::value)> { };
+}}
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct has_nothrow_assign_imp{
+   static const bool value = ((__has_nothrow_assign(T) ) && !is_volatile<T>::value && !is_const<T>::value);
+};
+}
+template< typename T > struct has_nothrow_assign : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { public: };
+template<> struct has_nothrow_assign< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T>
+struct has_nothrow_move_impl
+{
+    static const bool value = ( ::boost::mpl::or_< has_trivial_move<T> , ::boost::mpl::and_< has_nothrow_copy<T> , has_nothrow_assign<T> > >::type::value )
+         ;
+};
+template< typename T > struct has_nothrow_move : public ::boost::integral_constant<bool,(::boost::detail::variant::has_nothrow_move_impl<T>::value)> { };
+template <typename T>
+struct has_nothrow_move_constructor_impl
+{
+    static const bool value = ( ::boost::mpl::or_< has_nothrow_move<T> , has_trivial_move_constructor<T> , has_nothrow_copy<T> >::type::value )
+         ;
+};
+template< typename T > struct has_nothrow_move_constructor : public ::boost::integral_constant<bool,(::boost::detail::variant::has_nothrow_move_constructor_impl<T>::value)> { };
+template <typename T>
+struct has_nothrow_move_assign_impl
+{
+    static const bool value = ( ::boost::mpl::or_< has_nothrow_move<T> , has_trivial_move_assign<T> , has_nothrow_assign<T> >::type::value )
+         ;
+};
+template< typename T > struct has_nothrow_move_assign : public ::boost::integral_constant<bool,(::boost::detail::variant::has_nothrow_move_assign_impl<T>::value)> { };
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+struct apply_visitor_unrolled {};
+template <typename Iter, typename LastIter>
+struct visitation_impl_step
+{
+    typedef typename mpl::deref<Iter>::type type;
+    typedef typename mpl::next<Iter>::type next_iter;
+    typedef visitation_impl_step<
+          next_iter, LastIter
+        > next;
+};
+template <typename LastIter>
+struct visitation_impl_step< LastIter,LastIter >
+{
+    typedef apply_visitor_unrolled type;
+    typedef visitation_impl_step next;
+};
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    typename Visitor::result_type
+visitation_impl_invoke_impl(
+      int, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::true_
+    )
+{
+    return visitor.internal_visit(
+          cast_storage<T>(storage), 1L
+        );
+}
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    typename Visitor::result_type
+visitation_impl_invoke_impl(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::false_
+    )
+{
+    if (internal_which >= 0)
+    {
+        return visitor.internal_visit(
+              cast_storage<T>(storage), 1L
+            );
+    }
+    else
+    {
+        return visitor.internal_visit(
+              cast_storage< backup_holder<T> >(storage), 1L
+            );
+    }
+}
+template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
+inline
+    typename Visitor::result_type
+visitation_impl_invoke(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
+    , NoBackupFlag
+    , int
+    )
+{
+    typedef typename mpl::or_<
+          NoBackupFlag
+        , has_nothrow_move_constructor<T>
+        , has_nothrow_copy<T>
+        >::type never_uses_backup;
+    return (visitation_impl_invoke_impl)(
+          internal_which, visitor, storage, t
+        , never_uses_backup()
+        );
+}
+template <typename Visitor, typename VoidPtrCV, typename NBF>
+inline
+    typename Visitor::result_type
+visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
+{
+    (static_cast<void> (0));
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+template <
+      typename W, typename S
+    , typename Visitor, typename VPCV
+    , typename NBF
+    >
+inline
+    typename Visitor::result_type
+visitation_impl(
+      int, int, Visitor&, VPCV
+    , mpl::true_
+    , NBF, W* = 0, S* = 0
+    )
+{
+    (static_cast<void> (0));
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+template <
+      typename Which, typename step0
+    , typename Visitor, typename VoidPtrCV
+    , typename NoBackupFlag
+    >
+inline
+    typename Visitor::result_type
+visitation_impl(
+      const int internal_which, const int logical_which
+    , Visitor& visitor, VoidPtrCV storage
+    , mpl::false_
+    , NoBackupFlag no_backup_flag
+    , Which* = 0, step0* = 0
+    )
+{
+ typedef typename step0::type T0; typedef typename step0::next step1; typedef typename step1::type T1; typedef typename step1::next step2; typedef typename step2::type T2; typedef typename step2::next step3; typedef typename step3::type T3; typedef typename step3::next step4; typedef typename step4::type T4; typedef typename step4::next step5; typedef typename step5::type T5; typedef typename step5::next step6; typedef typename step6::type T6; typedef typename step6::next step7; typedef typename step7::type T7; typedef typename step7::next step8; typedef typename step8::type T8; typedef typename step8::next step9; typedef typename step9::type T9; typedef typename step9::next step10; typedef typename step10::type T10; typedef typename step10::next step11; typedef typename step11::type T11; typedef typename step11::next step12; typedef typename step12::type T12; typedef typename step12::next step13; typedef typename step13::type T13; typedef typename step13::next step14; typedef typename step14::type T14; typedef typename step14::next step15; typedef typename step15::type T15; typedef typename step15::next step16; typedef typename step16::type T16; typedef typename step16::next step17; typedef typename step17::type T17; typedef typename step17::next step18; typedef typename step18::type T18; typedef typename step18::next step19; typedef typename step19::type T19; typedef typename step19::next step20;
+    switch (logical_which)
+    {
+ case (Which::value + (0)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T0*>(0) , no_backup_flag, 1L ); case (Which::value + (1)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T1*>(0) , no_backup_flag, 1L ); case (Which::value + (2)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T2*>(0) , no_backup_flag, 1L ); case (Which::value + (3)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T3*>(0) , no_backup_flag, 1L ); case (Which::value + (4)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T4*>(0) , no_backup_flag, 1L ); case (Which::value + (5)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T5*>(0) , no_backup_flag, 1L ); case (Which::value + (6)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T6*>(0) , no_backup_flag, 1L ); case (Which::value + (7)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T7*>(0) , no_backup_flag, 1L ); case (Which::value + (8)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T8*>(0) , no_backup_flag, 1L ); case (Which::value + (9)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T9*>(0) , no_backup_flag, 1L ); case (Which::value + (10)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T10*>(0) , no_backup_flag, 1L ); case (Which::value + (11)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T11*>(0) , no_backup_flag, 1L ); case (Which::value + (12)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T12*>(0) , no_backup_flag, 1L ); case (Which::value + (13)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T13*>(0) , no_backup_flag, 1L ); case (Which::value + (14)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T14*>(0) , no_backup_flag, 1L ); case (Which::value + (15)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T15*>(0) , no_backup_flag, 1L ); case (Which::value + (16)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T16*>(0) , no_backup_flag, 1L ); case (Which::value + (17)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T17*>(0) , no_backup_flag, 1L ); case (Which::value + (18)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T18*>(0) , no_backup_flag, 1L ); case (Which::value + (19)): return (visitation_impl_invoke)( internal_which, visitor, storage , static_cast<T19*>(0) , no_backup_flag, 1L );
+    default: (static_cast<void> (0));
+    }
+    typedef mpl::int_<
+          Which::value + (20)
+        > next_which;
+    typedef step20
+        next_step;
+    typedef typename next_step::type next_type;
+    typedef typename is_same< next_type,apply_visitor_unrolled >::type
+        is_apply_visitor_unrolled;
+    return visitation_impl(
+          internal_which, logical_which
+        , visitor, storage
+        , is_apply_visitor_unrolled()
+        , no_backup_flag
+        , static_cast<next_which*>(0), static_cast<next_step*>(0)
+        );
+}
+}}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename Deriving> class moveable;
+template <typename T> class move_source;
+template <typename T> class move_return;
+namespace detail {
+template <typename Deriving>
+struct moveable_tag
+{
+};
+}
+namespace detail {
+template <typename T>
+struct move_type
+{
+public:
+    typedef typename mpl::if_<
+          is_base_and_derived<detail::moveable_tag<T>, T>
+        , move_source<T>
+        , T&
+        >::type type;
+};
+}
+template <typename T>
+inline
+    typename detail::move_type<T>::type
+move(T& source)
+{
+    typedef typename detail::move_type<T>::type
+        move_t;
+    return move_t(source);
+}
+template <typename T>
+struct return_t
+{
+public:
+    typedef typename mpl::if_<
+          is_base_and_derived<moveable<T>, T>
+        , move_return<T>
+        , T
+        >::type type;
+};
+template <typename T>
+inline void move_swap(T& lhs, T& rhs)
+{
+    T tmp( boost::detail::variant::move(lhs) );
+    lhs = boost::detail::variant::move(rhs);
+    rhs = boost::detail::variant::move(tmp);
+}
+}}
+}
+namespace boost {
+template <typename T> struct alignment_of;
+namespace detail {
+template <typename T>
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+    static const std::size_t value = A < S ? A : S;
+};
+template< typename T >
+struct alignment_of_impl
+{
+   static const std::size_t value = __alignof__(T);
+};
+}
+template< typename T > struct alignment_of : public ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { public: };
+template <typename T>
+struct alignment_of<T&>
+    : public alignment_of<T*>
+{
+};
+template<> struct alignment_of<void> : public ::boost::integral_constant<std::size_t,0> { public: };
+template<> struct alignment_of<void const> : public ::boost::integral_constant<std::size_t,0> { public: };
+template<> struct alignment_of<void volatile> : public ::boost::integral_constant<std::size_t,0> { public: };
+template<> struct alignment_of<void const volatile> : public ::boost::integral_constant<std::size_t,0> { public: };
+}
+namespace boost {
+namespace detail {
+class alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+template <bool found, std::size_t target, class TestType>
+struct lower_alignment_helper
+{
+    typedef char type;
+    enum { value = true };
+};
+template <std::size_t target, class TestType>
+struct lower_alignment_helper<false,target,TestType>
+{
+    enum { value = (alignment_of<TestType>::value == target) };
+    typedef typename mpl::if_c<value, TestType, char>::type type;
+};
+template <typename T>
+struct has_one_T
+{
+  T data;
+};
+template <std::size_t target>
+union lower_alignment
+{
+    enum { found0 = false };
+ typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< found7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };
+};
+union max_align
+{
+ char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;
+};
+template<std::size_t TAlign, std::size_t Align>
+struct is_aligned
+{
+    static const bool value = (TAlign >= Align) & (TAlign % Align == 0)
+         ;
+};
+}
+template<std::size_t Align>
+struct is_pod< ::boost::detail::lower_alignment<Align> >
+{
+        static const std::size_t value = true;
+};
+namespace detail{
+template <std::size_t Align>
+class type_with_alignment_imp
+{
+    typedef ::boost::detail::lower_alignment<Align> t1;
+    typedef typename mpl::if_c<
+          ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
+        , t1
+        , ::boost::detail::max_align
+        >::type align_t;
+    static const std::size_t found = alignment_of<align_t>::value;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found >= Align) == 0 ? false : true) >)> boost_static_assert_typedef_206;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found % Align == 0) == 0 ? false : true) >)> boost_static_assert_typedef_207;
+ public:
+    typedef align_t type;
+};
+}
+template <std::size_t Align>
+class type_with_alignment
+  : public ::boost::detail::type_with_alignment_imp<Align>
+{
+};
+namespace align {
+struct __attribute__((__aligned__(2))) a2 {};
+struct __attribute__((__aligned__(4))) a4 {};
+struct __attribute__((__aligned__(8))) a8 {};
+struct __attribute__((__aligned__(16))) a16 {};
+struct __attribute__((__aligned__(32))) a32 {};
+struct __attribute__((__aligned__(64))) a64 {};
+struct __attribute__((__aligned__(128))) a128 {};
+}
+template<> class type_with_alignment<1> { public: typedef char type; };
+template<> class type_with_alignment<2> { public: typedef align::a2 type; };
+template<> class type_with_alignment<4> { public: typedef align::a4 type; };
+template<> class type_with_alignment<8> { public: typedef align::a8 type; };
+template<> class type_with_alignment<16> { public: typedef align::a16 type; };
+template<> class type_with_alignment<32> { public: typedef align::a32 type; };
+template<> class type_with_alignment<64> { public: typedef align::a64 type; };
+template<> class type_with_alignment<128> { public: typedef align::a128 type; };
+namespace detail {
+template<> struct is_pod_impl< ::boost::align::a2 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a4 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a8 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a16 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a32 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a64 > { public: static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a128 > { public: static const bool value = (true); };
+}
+}
+namespace boost {
+namespace detail { namespace aligned_storage {
+static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value
+     ;
+template <
+      std::size_t size_
+    , std::size_t alignment_
+>
+struct aligned_storage_imp
+{
+    union data_t
+    {
+        char buf[size_];
+        typename mpl::eval_if_c<
+              alignment_ == std::size_t(-1)
+            , mpl::identity<detail::max_align>
+            , type_with_alignment<alignment_>
+            >::type align_;
+    } data_;
+    void* address() const { return const_cast<aligned_storage_imp*>(this); }
+};
+template< std::size_t alignment_ >
+struct aligned_storage_imp<0u,alignment_>
+{
+    void* address() const { return 0; }
+};
+}}
+template <
+      std::size_t size_
+    , std::size_t alignment_ = std::size_t(-1)
+>
+class aligned_storage :
+   private
+   detail::aligned_storage::aligned_storage_imp<size_, alignment_>
+{
+public:
+    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+    static const std::size_t size = size_
+         ;
+    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )
+         ;
+private:
+    aligned_storage(const aligned_storage&);
+    aligned_storage& operator=(const aligned_storage&);
+public:
+    aligned_storage()
+    {
+    }
+    ~aligned_storage()
+    {
+    }
+public:
+    void* address()
+    {
+        return static_cast<type*>(this)->address();
+    }
+    const void* address() const
+    {
+        return static_cast<const type*>(this)->address();
+    }
+};
+template <std::size_t size_, std::size_t alignment_>
+struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
+   : public ::boost::integral_constant<bool,true>
+{
+};
+}
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long int uint64_t;
+typedef signed char int_least8_t;
+typedef short int int_least16_t;
+typedef int int_least32_t;
+typedef long int int_least64_t;
+typedef unsigned char uint_least8_t;
+typedef unsigned short int uint_least16_t;
+typedef unsigned int uint_least32_t;
+typedef unsigned long int uint_least64_t;
+typedef signed char int_fast8_t;
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+typedef unsigned char uint_fast8_t;
+typedef unsigned long int uint_fast16_t;
+typedef unsigned long int uint_fast32_t;
+typedef unsigned long int uint_fast64_t;
+typedef unsigned long int uintptr_t;
+typedef long int intmax_t;
+typedef unsigned long int uintmax_t;
+namespace boost
+{
+  using ::int8_t;
+  using ::int_least8_t;
+  using ::int_fast8_t;
+  using ::uint8_t;
+  using ::uint_least8_t;
+  using ::uint_fast8_t;
+  using ::int16_t;
+  using ::int_least16_t;
+  using ::int_fast16_t;
+  using ::uint16_t;
+  using ::uint_least16_t;
+  using ::uint_fast16_t;
+  using ::int32_t;
+  using ::int_least32_t;
+  using ::int_fast32_t;
+  using ::uint32_t;
+  using ::uint_least32_t;
+  using ::uint_fast32_t;
+  using ::int64_t;
+  using ::int_least64_t;
+  using ::int_fast64_t;
+  using ::uint64_t;
+  using ::uint_least64_t;
+  using ::uint_fast64_t;
+  using ::intmax_t;
+  using ::uintmax_t;
+}
+namespace boost
+{
+namespace math
+{
+template < typename T >
+    class quaternion;
+template < >
+    class quaternion< float >;
+template < >
+    class quaternion< double >;
+template < >
+    class quaternion< long double >;
+template < typename T >
+    class octonion;
+template < >
+    class octonion< float >;
+template < >
+    class octonion< double >;
+template < >
+    class octonion< long double >;
+     typedef boost::uintmax_t static_gcd_type;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm;
+template < typename IntegerType >
+    class gcd_evaluator;
+template < typename IntegerType >
+    class lcm_evaluator;
+}
+}
+namespace boost
+{
+namespace math
+{
+namespace detail
+{
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd_helper_t
+    {
+    private:
+        static const static_gcd_type new_value1 = Value2;
+        static const static_gcd_type new_value2 = Value1 % Value2;
+        typedef static_gcd_helper_t< static_cast<static_gcd_type>(new_value1),
+         static_cast<static_gcd_type>(new_value2) > next_step_type;
+    public:
+        static const static_gcd_type value = next_step_type::value;
+    };
+    template < static_gcd_type Value1 >
+    struct static_gcd_helper_t< Value1, 0UL >
+    {
+        static const static_gcd_type value = Value1;
+    };
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm_helper_t
+    {
+        typedef static_gcd_helper_t<Value1, Value2> gcd_type;
+        static const static_gcd_type value = Value1 / gcd_type::value * Value2
+                   ;
+    };
+    template < >
+    struct static_lcm_helper_t< 0UL, 0UL >
+    {
+        static const static_gcd_type value = 0UL;
+    };
+}
+template < static_gcd_type Value1, static_gcd_type Value2 >
+struct static_gcd : public mpl::integral_c<static_gcd_type, (detail::static_gcd_helper_t<Value1, Value2>::value) >
+{
+};
+template < static_gcd_type Value1, static_gcd_type Value2 >
+struct static_lcm : public mpl::integral_c<static_gcd_type, (detail::static_lcm_helper_t<Value1, Value2>::value) >
+{
+};
+}
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct has_nothrow_constructor_imp{
+   static const bool value = (__has_nothrow_constructor(T) );
+};
+}
+template< typename T > struct has_nothrow_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { public: };
+template< typename T > struct has_nothrow_default_constructor : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { public: };
+template<> struct has_nothrow_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_default_constructor< void > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_default_constructor< void const > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_default_constructor< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
+template<> struct has_nothrow_default_constructor< void volatile > : public ::boost::integral_constant<bool,false> { public: };
+}
+namespace boost {
+namespace detail {
+    struct is_static_visitor_tag { };
+    typedef void static_visitor_default_return;
+}
+template <typename R = ::boost::detail::static_visitor_default_return>
+class static_visitor
+    : public detail::is_static_visitor_tag
+{
+public:
+    typedef R result_type;
+protected:
+    static_visitor() { }
+    ~static_visitor() { }
+};
+namespace detail {
+template <typename T>
+struct is_static_visitor_impl
+{
+    static const bool value = (::boost::is_base_and_derived< detail::is_static_visitor_tag, T >::value)
+                  ;
+};
+}
+template< typename T > struct is_static_visitor : public ::boost::integral_constant<bool,(::boost::detail::is_static_visitor_impl<T>::value)> { public: };
+}
+namespace boost { namespace mpl { namespace aux {
+template<
+      typename F
+    , typename Iterator
+    >
+struct iter_apply1
+    : apply1< F,typename deref<Iterator>::type >
+{
+};
+template<
+      typename F
+    , typename Iterator1
+    , typename Iterator2
+    >
+struct iter_apply2
+    : apply2<
+          F
+        , typename deref<Iterator1>::type
+        , typename deref<Iterator2>::type
+        >
+{
+};
+}}}
+namespace boost { namespace mpl { namespace aux {
+template< typename Predicate >
+struct find_if_pred
+{
+    template< typename Iterator >
+    struct apply
+    {
+        typedef not_< aux::iter_apply1<Predicate,Iterator> > type;
+    };
+};
+}}}
+namespace boost { namespace mpl {
+template< typename Value > struct always
+{
+    template<
+          typename T
+        , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na
+        >
+    struct apply
+    {
+        typedef Value type;
+    };
+};
+}}
+namespace boost { namespace mpl { namespace aux {
+template< typename Iterator, typename State >
+struct iter_fold_if_null_step
+{
+    typedef State state;
+    typedef Iterator iterator;
+};
+template< bool >
+struct iter_fold_if_step_impl
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef typename apply2< StateOp,State,Iterator >::type state;
+        typedef typename IteratorOp::type iterator;
+    };
+};
+template<>
+struct iter_fold_if_step_impl<false>
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef State state;
+        typedef Iterator iterator;
+    };
+};
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_forward_step
+{
+    typedef typename apply2< Predicate,State,Iterator >::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          not_last::value
+        >::template result_< Iterator,State,ForwardOp, mpl::next<Iterator> > impl_;
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+template<
+      typename Iterator
+    , typename State
+    , typename BackwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_backward_step
+{
+    typedef typename apply2< Predicate,State,Iterator >::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          not_last::value
+        >::template result_< Iterator,State,BackwardOp, identity<Iterator> > impl_;
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename ForwardPredicate
+    , typename BackwardOp
+    , typename BackwardPredicate
+    >
+struct iter_fold_if_impl
+{
+ private:
+    typedef iter_fold_if_null_step< Iterator,State > forward_step0;
+    typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1;
+    typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2;
+    typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3;
+    typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4;
+    typedef typename if_<
+          typename forward_step4::not_last
+        , iter_fold_if_impl<
+              typename forward_step4::iterator
+            , typename forward_step4::state
+            , ForwardOp
+            , ForwardPredicate
+            , BackwardOp
+            , BackwardPredicate
+            >
+        , iter_fold_if_null_step<
+              typename forward_step4::iterator
+            , typename forward_step4::state
+            >
+        >::type backward_step4;
+    typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3;
+    typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2;
+    typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1;
+    typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0;
+ public:
+    typedef typename backward_step0::state state;
+    typedef typename backward_step4::iterator iterator;
+};
+}}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Predicate, typename LastIterator >
+struct iter_fold_if_pred
+{
+    template< typename State, typename Iterator > struct apply
+        : and_<
+              not_< is_same<Iterator,LastIterator> >
+            , apply1<Predicate,Iterator>
+            >
+    {
+    };
+};
+}
+template<
+      typename Sequence = na
+    , typename State = na
+    , typename ForwardOp = na
+    , typename ForwardPredicate = na
+    , typename BackwardOp = na
+    , typename BackwardPredicate = na
+    >
+struct iter_fold_if
+{
+    typedef typename begin<Sequence>::type first_;
+    typedef typename end<Sequence>::type last_;
+    typedef typename eval_if<
+          is_na<BackwardPredicate>
+        , if_< is_na<BackwardOp>, always<false_>, always<true_> >
+        , identity<BackwardPredicate>
+        >::type backward_pred_;
+    struct result_ :
+        aux::iter_fold_if_impl<
+          first_
+        , State
+        , ForwardOp
+        , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > >
+        , BackwardOp
+        , backward_pred_
+        >
+    { };
+public:
+    typedef pair<
+          typename result_::state
+        , typename result_::iterator
+        > type;
+};
+template<> struct iter_fold_if< na , na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct apply : iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > { }; }; template< typename Tag > struct lambda< iter_fold_if< na , na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold_if< na , na , na , na , na , na > result_; typedef iter_fold_if< na , na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > > : int_<6> { }; template<> struct template_arity< iter_fold_if< na , na , na , na , na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename Predicate = na
+    >
+struct find_if
+{
+    typedef typename iter_fold_if<
+          Sequence
+        , void
+        , mpl::arg<1>
+        , protect< aux::find_if_pred<Predicate> >
+        >::type result_;
+    typedef typename second<result_>::type type;
+};
+template<> struct find_if< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find_if< T1 , T2 > { }; }; template< typename Tag > struct lambda< find_if< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find_if< na , na > result_; typedef find_if< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find_if< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find_if< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+namespace aux {
+template< typename Predicate >
+struct select_max
+{
+    template< typename OldIterator, typename Iterator >
+    struct apply
+    {
+        typedef typename apply2<
+              Predicate
+            , typename deref<OldIterator>::type
+            , typename deref<Iterator>::type
+            >::type condition_;
+        typedef typename if_<
+              condition_
+            , Iterator
+            , OldIterator
+            >::type type;
+    };
+};
+}
+template<
+      typename Sequence = na
+    , typename Predicate = less<_,_>
+    >
+struct max_element
+    : iter_fold<
+          Sequence
+        , typename begin<Sequence>::type
+        , protect< aux::select_max<Predicate> >
+        >
+{
+};
+template<> struct max_element< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max_element< T1 > { }; }; template< typename Tag > struct lambda< max_element< na > , Tag , int_<-1> > { typedef false_ is_le; typedef max_element< na > result_; typedef max_element< na > type; }; namespace aux { template< typename T1 > struct template_arity< max_element< T1 > > : int_<1> { }; template<> struct template_arity< max_element< na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<
+      typename T = na
+    >
+struct sizeof_
+    : mpl::size_t< sizeof(T) >
+{
+};
+template<> struct sizeof_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sizeof_< T1 > { }; }; template< typename Tag > struct lambda< sizeof_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sizeof_< na > result_; typedef sizeof_< na > type; }; namespace aux { template< typename T1 > struct template_arity< sizeof_< T1 > > : int_<1> { }; template<> struct template_arity< sizeof_< na > > : int_<-1> { }; }
+}}
+namespace boost {
+namespace detail { namespace variant {
+template <typename Sequence, typename F>
+struct max_value
+{
+private:
+    typedef typename mpl::transform1<Sequence, F>::type transformed_;
+    typedef typename mpl::max_element<transformed_
+        >::type max_it;
+public:
+    typedef typename mpl::deref<max_it>::type
+        type;
+};
+struct add_alignment
+{
+    template <typename State, typename Item>
+    struct apply
+        : mpl::size_t<
+              ::boost::math::static_lcm<
+                  State::value
+                , ::boost::alignment_of<Item>::value
+                >::value
+            >
+    {};
+};
+class no_fallback_type;
+struct find_fallback_type_pred
+{
+    template <typename Iterator>
+    struct apply
+    {
+    private:
+        typedef typename mpl::deref<Iterator>::type t_;
+    public:
+        typedef mpl::not_< has_nothrow_constructor<t_> > type;
+    };
+};
+template <typename Types>
+struct find_fallback_type
+{
+private:
+    typedef typename mpl::end<Types>::type end_it;
+    typedef typename mpl::iter_fold_if<
+          Types
+        , mpl::int_<0>, mpl::protect< mpl::next<> >
+        , mpl::protect< find_fallback_type_pred >
+        >::type first_result_;
+    typedef typename first_result_::first first_result_index;
+    typedef typename first_result_::second first_result_it;
+    typedef typename mpl::iter_fold_if<
+          mpl::iterator_range< first_result_it,end_it >
+        , first_result_index, mpl::protect< mpl::next<> >
+        , mpl::protect< mpl::not_same_as<boost::blank> >
+        >::type second_result_;
+    typedef typename second_result_::second second_result_it;
+public:
+    typedef typename mpl::eval_if<
+          is_same< second_result_it,end_it >
+        , mpl::if_<
+              is_same< first_result_it,end_it >
+            , mpl::pair< no_fallback_type,no_fallback_type >
+            , first_result_
+            >
+        , mpl::identity< second_result_ >
+        >::type type;
+};
+template <typename Types, typename NeverUsesBackupFlag>
+struct make_storage
+{
+private:
+    typedef typename mpl::eval_if<
+          NeverUsesBackupFlag
+        , mpl::identity< Types >
+        , mpl::push_front<
+              Types, backup_holder<void*>
+            >
+        >::type types;
+    typedef typename max_value<
+          types, mpl::sizeof_<mpl::_1>
+        >::type max_size;
+    typedef typename mpl::fold<
+          types
+        , mpl::size_t<1>
+        , add_alignment
+        >::type max_alignment;
+public:
+    typedef ::boost::aligned_storage<
+          max_size::value
+        , max_alignment::value
+        > type;
+};
+struct destroyer
+    : public static_visitor<>
+{
+public:
+    template <typename T>
+        void
+    internal_visit(T& operand, int) const
+    {
+        operand.~T();
+        ;
+    }
+};
+template <typename T>
+class known_get
+    : public static_visitor<T&>
+{
+public:
+    T& operator()(T& operand) const
+    {
+        return operand;
+    }
+    template <typename U>
+    T& operator()(U&) const
+    {
+        (static_cast<void> (0));
+        return ::boost::detail::variant::forced_return< T& >();
+    }
+};
+class copy_into
+    : public static_visitor<>
+{
+private:
+    void* storage_;
+public:
+    explicit copy_into(void* storage)
+        : storage_(storage)
+    {
+    }
+public:
+    template <typename T>
+        void
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        ;
+    }
+    template <typename T>
+        void
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        ;
+    }
+    template <typename T>
+        void
+    internal_visit(const T& operand, int) const
+    {
+        new(storage_) T(operand);
+        ;
+    }
+};
+struct assign_storage
+    : public static_visitor<>
+{
+private:
+    const void* rhs_storage_;
+public:
+    explicit assign_storage(const void* rhs_storage)
+        : rhs_storage_(rhs_storage)
+    {
+    }
+public:
+    template <typename T>
+        void
+    internal_visit(backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        ;
+    }
+    template <typename T>
+        void
+    internal_visit(const backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        ;
+    }
+    template <typename T>
+        void
+    internal_visit(T& lhs_content, int) const
+    {
+        lhs_content = *static_cast< const T* >(rhs_storage_);
+        ;
+    }
+};
+template <typename T>
+class direct_assigner
+    : public static_visitor<bool>
+{
+private:
+    const T& rhs_;
+public:
+    explicit direct_assigner(const T& rhs)
+        : rhs_(rhs)
+    {
+    }
+public:
+    bool operator()(T& lhs)
+    {
+        lhs = rhs_;
+        return true;
+    }
+    template <typename U>
+    bool operator()(U&)
+    {
+        return false;
+    }
+};
+template <typename Variant>
+class backup_assigner
+    : public static_visitor<>
+{
+private:
+    Variant& lhs_;
+    int rhs_which_;
+    const void* rhs_content_;
+    void (*copy_rhs_content_)(void*, const void*);
+public:
+    template<class RhsT>
+    backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)
+        : lhs_(lhs)
+        , rhs_which_(rhs_which)
+        , rhs_content_(&rhs_content)
+        , copy_rhs_content_(&construct_impl<RhsT>)
+    {
+    }
+private:
+    template<class RhsT>
+    static void construct_impl(void* addr, const void* obj)
+    {
+        new(addr) RhsT(*static_cast<const RhsT*>(obj));
+    }
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::true_
+        )
+    {
+        LhsT backup_lhs_content(
+              ::boost::detail::variant::move(lhs_content)
+            );
+        lhs_content.~LhsT();
+        try
+        {
+            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
+        }
+        catch (...)
+        {
+            new(lhs_.storage_.address())
+                LhsT(
+                      ::boost::detail::variant::move(backup_lhs_content)
+                    );
+            throw;
+        }
+        lhs_.indicate_which(rhs_which_);
+    }
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::false_
+        )
+    {
+        LhsT* backup_lhs_ptr = new LhsT(lhs_content);
+        lhs_content.~LhsT();
+        try
+        {
+            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
+        }
+        catch (...)
+        {
+            new(lhs_.storage_.address())
+                backup_holder<LhsT>( backup_lhs_ptr );
+            lhs_.indicate_backup_which( lhs_.which() );
+            throw;
+        }
+        lhs_.indicate_which(rhs_which_);
+        delete backup_lhs_ptr;
+    }
+public:
+    template <typename LhsT>
+        void
+    internal_visit(LhsT& lhs_content, int)
+    {
+        typedef typename has_nothrow_move_constructor<LhsT>::type
+            nothrow_move;
+        backup_assign_impl( lhs_content, nothrow_move() );
+        ;
+    }
+};
+template <typename Variant>
+struct swap_with
+    : public static_visitor<>
+{
+private:
+    Variant& toswap_;
+public:
+    explicit swap_with(Variant& toswap)
+        : toswap_(toswap)
+    {
+    }
+public:
+    template <typename T>
+    void operator()(T& operand) const
+    {
+        known_get<T> getter;
+        T& other = toswap_.apply_visitor(getter);
+        ::boost::detail::variant::move_swap( operand, other );
+    }
+private:
+    swap_with& operator=(const swap_with&);
+};
+class reflect
+    : public static_visitor<const std::type_info&>
+{
+public:
+    template <typename T>
+    const std::type_info& operator()(const T&) const
+    {
+        return typeid(T);
+    }
+};
+template <typename Variant, typename Comp>
+class comparer
+    : public static_visitor<bool>
+{
+private:
+    const Variant& lhs_;
+public:
+    explicit comparer(const Variant& lhs)
+        : lhs_(lhs)
+    {
+    }
+public:
+    template <typename T>
+    bool operator()(const T& rhs_content) const
+    {
+        known_get<const T> getter;
+        const T& lhs_content = lhs_.apply_visitor(getter);
+        return Comp()(lhs_content, rhs_content);
+    }
+private:
+    comparer& operator=(const comparer&);
+};
+struct equal_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs == rhs;
+    }
+};
+struct less_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs < rhs;
+    }
+};
+template <typename Visitor>
+class invoke_visitor
+{
+private:
+    Visitor& visitor_;
+public:
+    typedef typename Visitor::result_type
+        result_type;
+public:
+    explicit invoke_visitor(Visitor& visitor)
+        : visitor_(visitor)
+    {
+    }
+public:
+    template <typename T>
+    result_type internal_visit(T& operand, int)
+    {
+        return visitor_(operand);
+    }
+public:
+    template <typename T>
+        result_type
+    internal_visit(boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+    template <typename T>
+        result_type
+    internal_visit(const boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+    template <typename T>
+        result_type
+    internal_visit(boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+    template <typename T>
+        result_type
+    internal_visit(const boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+    template <typename T>
+        result_type
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+    template <typename T>
+        result_type
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+};
+}}
+template <
+      typename T0_
+    , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
+    >
+class variant
+{
+private:
+    typedef variant wknd_self_t;
+    struct is_recursive_
+        : detail::variant::is_recursive_flag<T0_>
+    {
+    };
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , T0_
+        , mpl::identity< T0_ >
+        >::type unwrapped_T0_;
+    struct is_sequence_based_
+        : detail::variant::is_over_sequence<unwrapped_T0_>
+    {
+    };
+private:
+    typedef typename mpl::eval_if<
+          is_sequence_based_
+        , unwrapped_T0_
+        , detail::variant::make_variant_list<
+              unwrapped_T0_
+            , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+            >
+        >::type specified_types;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( ::boost::mpl::not_< mpl::empty<specified_types> >::value )) == 0 ? false : true) >)>
+ boost_static_assert_typedef_1001;
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , mpl::transform<
+              specified_types
+            , mpl::protect<
+                  detail::variant::quoted_enable_recursive<wknd_self_t>
+                >
+            >
+        , mpl::identity< specified_types >
+        >::type recursive_enabled_types;
+public:
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , unwrap_recursive<mpl::_1>
+        >::type types;
+private:
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , mpl::protect< detail::make_reference_content<> >
+        >::type internal_types;
+    typedef typename mpl::front<
+          internal_types
+        >::type internal_T0;
+private:
+    typedef typename detail::variant::find_fallback_type<
+          internal_types
+        >::type fallback_type_result_;
+    typedef typename fallback_type_result_::first
+        fallback_type_index_;
+    typedef typename fallback_type_result_::second
+        fallback_type_;
+    struct has_fallback_type_
+        : mpl::not_<
+              is_same< fallback_type_, detail::variant::no_fallback_type >
+            >
+    {
+    };
+    typedef has_fallback_type_
+        never_uses_backup_flag;
+    typedef typename detail::variant::make_storage<
+          internal_types, never_uses_backup_flag
+        >::type storage_t;
+private:
+    typedef int which_t;
+    private:
+    which_t which_;
+    storage_t storage_;
+    void indicate_which(int which_arg)
+    {
+        which_ = static_cast<which_t>( which_arg );
+    }
+    void indicate_backup_which(int which_arg)
+    {
+        which_ = static_cast<which_t>( -(which_arg + 1) );
+    }
+private:
+    bool using_backup() const
+    {
+        return which_ < 0;
+    }
+public:
+    int which() const
+    {
+        if (using_backup())
+            return -(which_ + 1);
+        return which_;
+    }
+private:
+    struct initializer
+        : ::boost::mpl::iter_fold< recursive_enabled_types , ::boost::mpl::pair< ::boost::detail::variant::initializer_root , ::boost::mpl::int_<0> > , ::boost::mpl::protect< ::boost::detail::variant::make_initializer_node > >::type::first
+    {
+    };
+    void destroy_content()
+    {
+        detail::variant::destroyer visitor;
+        this->internal_apply_visitor(visitor);
+    }
+public:
+    ~variant()
+    {
+        destroy_content();
+    }
+    variant()
+    {
+        new( storage_.address() ) internal_T0();
+        indicate_which(0);
+    }
+private:
+    class convert_copy_into
+        : public static_visitor<int>
+    {
+    private:
+        void* storage_;
+    public:
+        explicit convert_copy_into(void* storage)
+            : storage_(storage)
+        {
+        }
+    public:
+        template <typename T>
+        int internal_visit(T& operand, int) const
+        {
+            return initializer::initialize(storage_, operand);
+        }
+        template <typename T>
+        int internal_visit(boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+        template <typename T>
+        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+        template <typename T>
+        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+        template <typename T>
+        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+        template <typename T>
+        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+        template <typename T>
+        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+    };
+    friend class convert_copy_into;
+private:
+    template <typename T>
+    void convert_construct(
+          T& operand
+        , int
+        , mpl::false_ = mpl::false_()
+        )
+    {
+        indicate_which(
+              initializer::initialize(
+                  storage_.address()
+                , operand
+                )
+            );
+    }
+    template <typename Variant>
+    void convert_construct(
+          Variant& operand
+        , long
+        , mpl::true_
+        )
+    {
+        convert_copy_into visitor(storage_.address());
+        indicate_which(
+              operand.internal_apply_visitor(visitor)
+            );
+    }
+    template <typename Variant>
+    void convert_construct_variant(Variant& operand)
+    {
+        typedef typename mpl::find_if<
+              types
+            , is_same<
+                  add_const<mpl::_1>
+                , const Variant
+                >
+            >::type found_it;
+        typedef typename mpl::end<types>::type not_found;
+        typedef typename is_same<
+              found_it, not_found
+            >::type is_foreign_variant;
+        convert_construct(
+              operand, 1L
+            , is_foreign_variant()
+            );
+    }
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>
+    void convert_construct(
+          boost::variant< U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);
+    }
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19>
+    void convert_construct(
+          const boost::variant< U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);
+    }
+public:
+    template <typename T>
+    variant(const T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+    template <typename T>
+    variant(T& operand)
+    {
+        convert_construct(operand, 1L);
+    }
+public:
+    variant(const variant& operand)
+    {
+        detail::variant::copy_into visitor( storage_.address() );
+        operand.internal_apply_visitor(visitor);
+        indicate_which(operand.which());
+    }
+private:
+    template <typename Variant>
+    friend class detail::variant::backup_assigner;
+    class assigner
+        : public static_visitor<>
+    {
+    private:
+        variant& lhs_;
+        int rhs_which_;
+    public:
+        assigner(variant& lhs, int rhs_which)
+            : lhs_(lhs)
+            , rhs_which_(rhs_which)
+        {
+        }
+    private:
+        template <typename RhsT, typename B1, typename B2>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::true_
+            , B1
+            , B2
+            )
+        {
+            lhs_.destroy_content();
+            new(lhs_.storage_.address())
+                RhsT( rhs_content );
+            lhs_.indicate_which(rhs_which_);
+        }
+        template <typename RhsT, typename B>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_
+            , mpl::true_
+            , B
+            )
+        {
+            RhsT temp(rhs_content);
+            lhs_.destroy_content();
+            new(lhs_.storage_.address())
+                RhsT( detail::variant::move(temp) );
+            lhs_.indicate_which(rhs_which_);
+        }
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_
+            , mpl::false_
+            , mpl::true_
+            )
+        {
+            lhs_.destroy_content();
+            try
+            {
+                new(lhs_.storage_.address())
+                    RhsT( rhs_content );
+            }
+            catch (...)
+            {
+                new (lhs_.storage_.address())
+                    fallback_type_;
+                lhs_.indicate_which(
+                      fallback_type_index_::value
+                    );
+                throw;
+            }
+            lhs_.indicate_which(rhs_which_);
+        }
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_
+            , mpl::false_
+            , mpl::false_
+            )
+        {
+            detail::variant::backup_assigner<wknd_self_t>
+                visitor(lhs_, rhs_which_, rhs_content);
+            lhs_.internal_apply_visitor(visitor);
+        }
+    public:
+        template <typename RhsT>
+            void
+        internal_visit(const RhsT& rhs_content, int)
+        {
+            typedef typename has_nothrow_copy<RhsT>::type
+                nothrow_copy;
+            typedef typename mpl::or_<
+                  nothrow_copy
+                , detail::variant::has_nothrow_move_constructor<RhsT>
+                >::type nothrow_move_constructor;
+            assign_impl(
+                  rhs_content
+                , nothrow_copy()
+                , nothrow_move_constructor()
+                , has_fallback_type_()
+                );
+            ;
+        }
+    };
+    friend class assigner;
+    void variant_assign(const variant& rhs)
+    {
+        if (which_ == rhs.which_)
+        {
+            detail::variant::assign_storage visitor(rhs.storage_.address());
+            this->internal_apply_visitor(visitor);
+        }
+        else
+        {
+            assigner visitor(*this, rhs.which());
+            rhs.internal_apply_visitor(visitor);
+        }
+    }
+private:
+    template <typename T>
+    void assign(const T& rhs)
+    {
+        detail::variant::direct_assigner<T> direct_assign(rhs);
+        if (this->apply_visitor(direct_assign) == false)
+        {
+            variant temp(rhs);
+            variant_assign( detail::variant::move(temp) );
+        }
+    }
+public:
+    template <typename T>
+    variant& operator=(const T& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+    variant& operator=(const variant& rhs)
+    {
+        variant_assign(rhs);
+        return *this;
+    }
+    void swap(variant& rhs)
+    {
+        if (which() == rhs.which())
+        {
+            detail::variant::swap_with<variant> visitor(rhs);
+            this->apply_visitor(visitor);
+        }
+        else
+        {
+            variant tmp( detail::variant::move(rhs) );
+            rhs = detail::variant::move(*this);
+            *this = detail::variant::move(tmp);
+        }
+    }
+public:
+    bool empty() const
+    {
+        return false;
+    }
+    const std::type_info& type() const
+    {
+        detail::variant::reflect visitor;
+        return this->apply_visitor(visitor);
+    }
+public:
+    template <typename U>
+        void
+    operator==(const U&) const
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((false && sizeof(U)) == 0 ? false : true) >)> boost_static_assert_typedef_1723;
+    }
+    template <typename U>
+        void
+    operator<(const U&) const
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((false && sizeof(U)) == 0 ? false : true) >)> boost_static_assert_typedef_1730;
+    }
+public:
+    bool operator==(const variant& rhs) const
+    {
+        if (this->which() != rhs.which())
+            return false;
+        detail::variant::comparer<
+              variant, detail::variant::equal_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+    bool operator<(const variant& rhs) const
+    {
+        if (this->which() != rhs.which())
+            return this->which() < rhs.which();
+        detail::variant::comparer<
+              variant, detail::variant::less_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+    template < typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19 >
+    friend class variant;
+private:
+    template <typename Visitor, typename VoidPtrCV>
+    static
+        typename Visitor::result_type
+    internal_apply_visitor_impl(
+          int internal_which
+        , int logical_which
+        , Visitor& visitor
+        , VoidPtrCV storage
+        )
+    {
+        typedef mpl::int_<0> first_which;
+        typedef typename mpl::begin<internal_types>::type first_it;
+        typedef typename mpl::end<internal_types>::type last_it;
+        typedef detail::variant::visitation_impl_step<
+              first_it, last_it
+            > first_step;
+        return detail::variant::visitation_impl(
+              internal_which, logical_which
+            , visitor, storage, mpl::false_()
+            , never_uses_backup_flag()
+            , static_cast<first_which*>(0), static_cast<first_step*>(0)
+            );
+    }
+    template <typename Visitor>
+        typename Visitor::result_type
+    internal_apply_visitor(Visitor& visitor)
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+    template <typename Visitor>
+        typename Visitor::result_type
+    internal_apply_visitor(Visitor& visitor) const
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+public:
+    template <typename Visitor>
+        typename Visitor::result_type
+    apply_visitor(Visitor& visitor)
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+    template <typename Visitor>
+        typename Visitor::result_type
+    apply_visitor(Visitor& visitor) const
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+};
+template <typename Types>
+struct make_variant_over
+{
+private:
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( ::boost::mpl::is_sequence<Types>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_1862;
+public:
+    typedef variant<
+          detail::variant::over_sequence< Types >
+        > type;
+};
+template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+inline void swap(
+      variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >& lhs
+    , variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >& rhs
+    )
+{
+    lhs.swap(rhs);
+}
+}
+namespace boost {
+template <
+      typename E , typename T
+    ,
+      typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19
+    >
+inline std::basic_ostream< E , T >& operator<<(
+      std::basic_ostream< E , T >& out
+    , const variant< U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 >& rhs
+    );
+namespace detail { namespace variant {
+template <typename OStream>
+class printer
+    : public boost::static_visitor<>
+{
+private:
+    OStream& out_;
+public:
+    explicit printer(OStream& out)
+        : out_( out )
+    {
+    }
+public:
+    template <typename T>
+    void operator()(const T& operand) const
+    {
+        out_ << operand;
+    }
+private:
+    printer& operator=(const printer&);
+};
+}}
+template <
+      typename E , typename T
+    ,
+      typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9 , typename U10 , typename U11 , typename U12 , typename U13 , typename U14 , typename U15 , typename U16 , typename U17 , typename U18 , typename U19
+    >
+inline std::basic_ostream< E , T >& operator<<(
+      std::basic_ostream< E , T >& out
+    , const variant< U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9 , U10 , U11 , U12 , U13 , U14 , U15 , U16 , U17 , U18 , U19 >& rhs
+    )
+{
+    detail::variant::printer<
+          std::basic_ostream< E , T >
+        > visitor(out);
+    rhs.apply_visitor(visitor);
+    return out;
+}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <
+      typename T, typename Dest, typename Source
+      , typename Arity
+    >
+struct substitute
+{
+    typedef T type;
+};
+template <typename Dest, typename Source> struct substitute< Source , Dest , Source , mpl::int_<-1> > { typedef Dest type; };
+template <typename Dest, typename Source> struct substitute< const Source , Dest , Source , mpl::int_<-1> > { typedef const Dest type; };
+template <typename Dest, typename Source> struct substitute< volatile Source , Dest , Source , mpl::int_<-1> > { typedef volatile Dest type; };
+template <typename Dest, typename Source> struct substitute< const volatile Source , Dest , Source , mpl::int_<-1> > { typedef const volatile Dest type; };
+template <typename T, typename Dest, typename Source> struct substitute< T * , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * type; };
+template <typename T, typename Dest, typename Source> struct substitute< T * const , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * const type; };
+template <typename T, typename Dest, typename Source> struct substitute< T * volatile , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * volatile type; };
+template <typename T, typename Dest, typename Source> struct substitute< T * const volatile , Dest , Source , mpl::int_<-1> > { typedef typename substitute< T, Dest, Source >::type * const volatile type; };
+template <typename T, typename Dest, typename Source>
+struct substitute<
+      T&
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+    typedef typename substitute<
+          T, Dest, Source
+        >::type & type;
+};
+template <
+      typename R, typename Dest, typename Source
+    >
+struct substitute<
+      R (*)( void )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+public:
+    typedef r (*type)( void );
+};
+template <
+      template < typename P1 > class T
+    , typename U1
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< U1 >
+    , Dest
+    , Source
+      , mpl::int_<( 1 )>
+    >
+{
+private:
+    typedef typename substitute< U1, Dest, Source >::type u1;
+public:
+    typedef T< u1 > type;
+};
+template <
+      typename R
+    , typename U1
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( U1 )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    typedef typename substitute< U1, Dest, Source >::type u1;
+public:
+    typedef r (*type)( u1 );
+};
+template <
+      template < typename P1 , typename P2 > class T
+    , typename U1 , typename U2
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< U1 , U2 >
+    , Dest
+    , Source
+      , mpl::int_<( 2 )>
+    >
+{
+private:
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2;
+public:
+    typedef T< u1 , u2 > type;
+};
+template <
+      typename R
+    , typename U1 , typename U2
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( U1 , U2 )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2;
+public:
+    typedef r (*type)( u1 , u2 );
+};
+template <
+      template < typename P1 , typename P2 , typename P3 > class T
+    , typename U1 , typename U2 , typename U3
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< U1 , U2 , U3 >
+    , Dest
+    , Source
+      , mpl::int_<( 3 )>
+    >
+{
+private:
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3;
+public:
+    typedef T< u1 , u2 , u3 > type;
+};
+template <
+      typename R
+    , typename U1 , typename U2 , typename U3
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( U1 , U2 , U3 )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3;
+public:
+    typedef r (*type)( u1 , u2 , u3 );
+};
+template <
+      template < typename P1 , typename P2 , typename P3 , typename P4 > class T
+    , typename U1 , typename U2 , typename U3 , typename U4
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< U1 , U2 , U3 , U4 >
+    , Dest
+    , Source
+      , mpl::int_<( 4 )>
+    >
+{
+private:
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3; typedef typename substitute< U4, Dest, Source >::type u4;
+public:
+    typedef T< u1 , u2 , u3 , u4 > type;
+};
+template <
+      typename R
+    , typename U1 , typename U2 , typename U3 , typename U4
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( U1 , U2 , U3 , U4 )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3; typedef typename substitute< U4, Dest, Source >::type u4;
+public:
+    typedef r (*type)( u1 , u2 , u3 , u4 );
+};
+template <
+      template < typename P1 , typename P2 , typename P3 , typename P4 , typename P5 > class T
+    , typename U1 , typename U2 , typename U3 , typename U4 , typename U5
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< U1 , U2 , U3 , U4 , U5 >
+    , Dest
+    , Source
+      , mpl::int_<( 5 )>
+    >
+{
+private:
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3; typedef typename substitute< U4, Dest, Source >::type u4; typedef typename substitute< U5, Dest, Source >::type u5;
+public:
+    typedef T< u1 , u2 , u3 , u4 , u5 > type;
+};
+template <
+      typename R
+    , typename U1 , typename U2 , typename U3 , typename U4 , typename U5
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( U1 , U2 , U3 , U4 , U5 )
+    , Dest
+    , Source
+      , mpl::int_<-1>
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    typedef typename substitute< U1, Dest, Source >::type u1; typedef typename substitute< U2, Dest, Source >::type u2; typedef typename substitute< U3, Dest, Source >::type u3; typedef typename substitute< U4, Dest, Source >::type u4; typedef typename substitute< U5, Dest, Source >::type u5;
+public:
+    typedef r (*type)( u1 , u2 , u3 , u4 , u5 );
+};
+}}
+}
+namespace boost {
+template <typename T>
+class recursive_wrapper
+{
+public:
+    typedef T type;
+private:
+    T* p_;
+public:
+    ~recursive_wrapper();
+    recursive_wrapper();
+    recursive_wrapper(const recursive_wrapper& operand);
+    recursive_wrapper(const T& operand);
+private:
+    void assign(const T& rhs);
+public:
+    recursive_wrapper& operator=(const recursive_wrapper& rhs)
+    {
+        assign( rhs.get() );
+        return *this;
+    }
+    recursive_wrapper& operator=(const T& rhs)
+    {
+        assign( rhs );
+        return *this;
+    }
+    void swap(recursive_wrapper& operand)
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+public:
+    T& get() { return *get_pointer(); }
+    const T& get() const { return *get_pointer(); }
+    T* get_pointer() { return p_; }
+    const T* get_pointer() const { return p_; }
+};
+template <typename T>
+recursive_wrapper<T>::~recursive_wrapper()
+{
+    boost::checked_delete(p_);
+}
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper()
+    : p_(new T)
+{
+}
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand)
+    : p_(new T( operand.get() ))
+{
+}
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const T& operand)
+    : p_(new T(operand))
+{
+}
+template <typename T>
+void recursive_wrapper<T>::assign(const T& rhs)
+{
+    this->get() = rhs;
+}
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs)
+{
+    lhs.swap(rhs);
+}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename T, typename RecursiveVariant, typename NoWrapper>
+struct enable_recursive
+    : substitute< T , RecursiveVariant , ::boost::recursive_variant_ >
+{
+};
+template <typename T, typename RecursiveVariant>
+struct enable_recursive< T,RecursiveVariant,mpl::false_ >
+{
+private:
+    typedef typename substitute< T , RecursiveVariant , ::boost::recursive_variant_ >
+         ::type t_;
+public:
+    typedef typename mpl::if_<
+          mpl::or_<
+              is_same< t_,T >
+            , is_reference<t_>
+            , is_pointer<t_>
+            >
+        , t_
+        , boost::recursive_wrapper<t_>
+        >::type type;
+};
+template <typename RecursiveVariant, typename NoWrapper>
+struct quoted_enable_recursive
+{
+    template <typename T>
+    struct apply
+        : enable_recursive<T, RecursiveVariant, NoWrapper>
+    {
+    };
+};
+}}
+}
+namespace boost { namespace mpl {
+namespace aux {
+template<
+      typename Predicate
+    , typename LastIterator1
+    , typename LastIterator2
+    >
+struct equal_pred
+{
+    template<
+          typename Iterator2
+        , typename Iterator1
+        >
+    struct apply
+    {
+        typedef typename and_<
+              not_< is_same<Iterator1,LastIterator1> >
+            , not_< is_same<Iterator2,LastIterator2> >
+            , aux::iter_apply2<Predicate,Iterator1,Iterator2>
+            >::type type;
+    };
+};
+template<
+      typename Sequence1
+    , typename Sequence2
+    , typename Predicate
+    >
+struct equal_impl
+{
+    typedef typename begin<Sequence1>::type first1_;
+    typedef typename begin<Sequence2>::type first2_;
+    typedef typename end<Sequence1>::type last1_;
+    typedef typename end<Sequence2>::type last2_;
+    typedef aux::iter_fold_if_impl<
+          first1_
+        , first2_
+        , next<>
+        , protect< aux::equal_pred<Predicate,last1_,last2_> >
+        , void_
+        , always<false_>
+        > fold_;
+    typedef typename fold_::iterator iter1_;
+    typedef typename fold_::state iter2_;
+    typedef and_<
+          is_same<iter1_,last1_>
+        , is_same<iter2_,last2_>
+        > result_;
+    typedef typename result_::type type;
+};
+}
+template<
+      typename Sequence1 = na
+    , typename Sequence2 = na
+    , typename Predicate = is_same<_,_>
+    >
+struct equal
+    : aux::msvc_eti_base<
+          typename aux::equal_impl<Sequence1,Sequence2,Predicate>::type
+        >::type
+{
+};
+template<> struct equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal< na , na > result_; typedef equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal< na , na > > : int_<-1> { }; }
+}}
+namespace boost {
+namespace detail { namespace variant {
+template <
+      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
+    , typename RecursiveVariant
+      , typename Arity
+    >
+struct substitute<
+      ::boost::variant<
+          recursive_flag< T0 >
+        , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+        >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      , Arity
+    >
+{
+    typedef ::boost::variant<
+          recursive_flag< T0 >
+        , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+        > type;
+};
+template <
+      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
+    , typename RecursiveVariant
+      , typename Arity
+    >
+struct substitute<
+      ::boost::variant<
+          ::boost::detail::variant::over_sequence< T0 >
+        , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+        >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      , Arity
+    >
+{
+private:
+    typedef T0 initial_types;
+    typedef typename mpl::transform<
+          initial_types
+        , mpl::protect< quoted_enable_recursive<RecursiveVariant,mpl::true_> >
+        >::type types;
+public:
+    typedef typename mpl::if_<
+          mpl::equal<initial_types, types, ::boost::is_same<mpl::_1, mpl::_2> >
+        , ::boost::variant<
+              ::boost::detail::variant::over_sequence< T0 >
+            , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+            >
+        , ::boost::variant< over_sequence<types> >
+        >::type type;
+};
+template <
+      typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19
+    , typename RecursiveVariant
+      , typename Arity
+    >
+struct substitute<
+      ::boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      , Arity
+    >
+{
+private:
+ typedef typename enable_recursive< T0 , RecursiveVariant , mpl::true_ >::type wknd_T0; typedef typename enable_recursive< T1 , RecursiveVariant , mpl::true_ >::type wknd_T1; typedef typename enable_recursive< T2 , RecursiveVariant , mpl::true_ >::type wknd_T2; typedef typename enable_recursive< T3 , RecursiveVariant , mpl::true_ >::type wknd_T3; typedef typename enable_recursive< T4 , RecursiveVariant , mpl::true_ >::type wknd_T4; typedef typename enable_recursive< T5 , RecursiveVariant , mpl::true_ >::type wknd_T5; typedef typename enable_recursive< T6 , RecursiveVariant , mpl::true_ >::type wknd_T6; typedef typename enable_recursive< T7 , RecursiveVariant , mpl::true_ >::type wknd_T7; typedef typename enable_recursive< T8 , RecursiveVariant , mpl::true_ >::type wknd_T8; typedef typename enable_recursive< T9 , RecursiveVariant , mpl::true_ >::type wknd_T9; typedef typename enable_recursive< T10 , RecursiveVariant , mpl::true_ >::type wknd_T10; typedef typename enable_recursive< T11 , RecursiveVariant , mpl::true_ >::type wknd_T11; typedef typename enable_recursive< T12 , RecursiveVariant , mpl::true_ >::type wknd_T12; typedef typename enable_recursive< T13 , RecursiveVariant , mpl::true_ >::type wknd_T13; typedef typename enable_recursive< T14 , RecursiveVariant , mpl::true_ >::type wknd_T14; typedef typename enable_recursive< T15 , RecursiveVariant , mpl::true_ >::type wknd_T15; typedef typename enable_recursive< T16 , RecursiveVariant , mpl::true_ >::type wknd_T16; typedef typename enable_recursive< T17 , RecursiveVariant , mpl::true_ >::type wknd_T17; typedef typename enable_recursive< T18 , RecursiveVariant , mpl::true_ >::type wknd_T18; typedef typename enable_recursive< T19 , RecursiveVariant , mpl::true_ >::type wknd_T19;
+public:
+    typedef ::boost::variant< wknd_T0 , wknd_T1 , wknd_T2 , wknd_T3 , wknd_T4 , wknd_T5 , wknd_T6 , wknd_T7 , wknd_T8 , wknd_T9 , wknd_T10 , wknd_T11 , wknd_T12 , wknd_T13 , wknd_T14 , wknd_T15 , wknd_T16 , wknd_T17 , wknd_T18 , wknd_T19 > type;
+};
+}}
+template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+struct make_recursive_variant
+{
+public:
+    typedef boost::variant<
+          detail::variant::recursive_flag< T0 >
+        , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+        > type;
+};
+template <typename Types>
+struct make_recursive_variant_over
+{
+private:
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( ::boost::mpl::is_sequence<Types>::value )) == 0 ? false : true) >)> boost_static_assert_typedef_180;
+public:
+    typedef typename make_recursive_variant<
+          detail::variant::over_sequence< Types >
+        >::type type;
+};
+}
+namespace boost {
+template <typename Visitor, typename Visitable>
+inline
+    typename Visitor::result_type
+apply_visitor(Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+template <typename Visitor, typename Visitable>
+inline
+    typename Visitor::result_type
+apply_visitor(const Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+}
+namespace boost {
+namespace detail { namespace variant {
+template <typename Visitor, typename Value1>
+class apply_visitor_binary_invoke
+{
+public:
+    typedef typename Visitor::result_type
+        result_type;
+private:
+    Visitor& visitor_;
+    Value1& value1_;
+public:
+    apply_visitor_binary_invoke(Visitor& visitor, Value1& value1)
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+public:
+    template <typename Value2>
+        result_type
+    operator()(Value2& value2)
+    {
+        return visitor_(value1_, value2);
+    }
+private:
+    apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
+};
+template <typename Visitor, typename Visitable2>
+class apply_visitor_binary_unwrap
+{
+public:
+    typedef typename Visitor::result_type
+        result_type;
+private:
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+public:
+    apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2)
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+public:
+    template <typename Value1>
+        result_type
+    operator()(Value1& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            > invoker(visitor_, value1);
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+private:
+    apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);
+};
+}}
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    typename Visitor::result_type
+apply_visitor(
+      Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    typename Visitor::result_type
+apply_visitor(
+      const Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+}
+namespace boost {
+template <typename Visitor>
+class apply_visitor_delayed_t
+{
+public:
+    typedef typename Visitor::result_type
+        result_type;
+private:
+    Visitor& visitor_;
+public:
+    explicit apply_visitor_delayed_t(Visitor& visitor)
+      : visitor_(visitor)
+    {
+    }
+public:
+    template <typename Visitable>
+        result_type
+    operator()(Visitable& visitable) const
+    {
+        return apply_visitor(visitor_, visitable);
+    }
+public:
+    template <typename Visitable1, typename Visitable2>
+        result_type
+    operator()(Visitable1& visitable1, Visitable2& visitable2) const
+    {
+        return apply_visitor(visitor_, visitable1, visitable2);
+    }
+private:
+    apply_visitor_delayed_t& operator=(const apply_visitor_delayed_t&);
+};
+template <typename Visitor>
+inline apply_visitor_delayed_t<Visitor> apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_t<Visitor>(visitor);
+}
+}
+namespace boost {
+namespace noncopyable_
+{
+  class noncopyable
+  {
+   protected:
+      noncopyable() {}
+      ~noncopyable() {}
+   private:
+      noncopyable( const noncopyable& );
+      const noncopyable& operator=( const noncopyable& );
+  };
+}
+typedef noncopyable_::noncopyable noncopyable;
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        using type_traits::yes_type;
+        using type_traits::no_type;
+        yes_type is_string_impl( const char* const );
+        yes_type is_string_impl( const wchar_t* const );
+        no_type is_string_impl( ... );
+        template< std::size_t sz >
+        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
+        no_type is_char_array_impl( ... );
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
+        no_type is_wchar_t_array_impl( ... );
+        yes_type is_char_ptr_impl( char* const );
+        no_type is_char_ptr_impl( ... );
+        yes_type is_const_char_ptr_impl( const char* const );
+        no_type is_const_char_ptr_impl( ... );
+        yes_type is_wchar_t_ptr_impl( wchar_t* const );
+        no_type is_wchar_t_ptr_impl( ... );
+        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
+        no_type is_const_wchar_t_ptr_impl( ... );
+        template< typename Iterator >
+        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
+        no_type is_pair_impl( ... );
+        struct char_or_wchar_t_array_tag {};
+    }
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        typedef mpl::int_<1>::type std_container_;
+        typedef mpl::int_<2>::type std_pair_;
+        typedef mpl::int_<3>::type const_std_pair_;
+        typedef mpl::int_<4>::type array_;
+        typedef mpl::int_<5>::type const_array_;
+        typedef mpl::int_<6>::type char_array_;
+        typedef mpl::int_<7>::type wchar_t_array_;
+        typedef mpl::int_<8>::type char_ptr_;
+        typedef mpl::int_<9>::type const_char_ptr_;
+        typedef mpl::int_<10>::type wchar_t_ptr_;
+        typedef mpl::int_<11>::type const_wchar_t_ptr_;
+        typedef mpl::int_<12>::type string_;
+        template< typename C >
+        struct range_helper
+        {
+            static C* c;
+            static C ptr;
+            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
+            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value );
+            static const bool is_array_ = boost::is_array<C>::value;
+        };
+        template< typename C >
+        class range
+        {
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
+                                                                  boost::range_detail::std_pair_,
+                                                                  void >::type pair_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
+                                                                    boost::range_detail::array_,
+                                                                    pair_t >::type array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
+                                                                    boost::range_detail::string_,
+                                                                    array_t >::type string_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
+                                                                    boost::range_detail::const_char_ptr_,
+                                                                    string_t >::type const_char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
+                                                                    boost::range_detail::char_ptr_,
+                                                                    const_char_ptr_t >::type char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+                                                                    boost::range_detail::const_wchar_t_ptr_,
+                                                                    char_ptr_t >::type const_wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+                                                                    boost::range_detail::wchar_t_ptr_,
+                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
+                                                                    boost::range_detail::wchar_t_array_,
+                                                                    wchar_ptr_t >::type wchar_array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
+                                                                    boost::range_detail::char_array_,
+                                                                    wchar_array_t >::type char_array_t;
+        public:
+            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
+                                                                    boost::range_detail::std_container_,
+                                                                    char_array_t >::type type;
+        };
+    }
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        template <typename T>
+        inline void boost_range_silence_warning( const T& ) { }
+        inline const char* str_end( const char* s, const char* )
+        {
+            return s + strlen( s );
+        }
+        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
+        {
+            return s + wcslen( s );
+        }
+        template< class Char >
+        inline Char* str_end( Char* s )
+        {
+            return const_cast<Char*>( str_end( s, s ) );
+        }
+        template< class T, std::size_t sz >
+        inline T* array_end( T (&boost_range_array)[sz] )
+        {
+            return boost_range_array + sz;
+        }
+        template< class T, std::size_t sz >
+        inline const T* array_end( const T (&boost_range_array)[sz] )
+        {
+            return boost_range_array + sz;
+        }
+        template< class Char >
+        inline std::size_t str_size( const Char* const& s )
+        {
+            return str_end( s ) - s;
+        }
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( const T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+    }
+}
+namespace boost {
+    namespace range_detail {
+        template< typename T > struct exists { typedef void type; };
+    }
+}
+namespace boost { namespace detail {
+template <class Iterator>
+struct iterator_traits
+    : std::iterator_traits<Iterator>
+{};
+using std::distance;
+}}
+namespace boost {
+template <class Iterator>
+struct iterator_value
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
+};
+template <class Iterator>
+struct iterator_reference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+};
+template <class Iterator>
+struct iterator_pointer
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
+};
+template <class Iterator>
+struct iterator_difference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
+};
+template <class Iterator>
+struct iterator_category
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
+};
+}
+namespace boost
+{
+    namespace range_detail {
+        template< typename C, typename Enable=void > struct extract_iterator {}; template< typename C > struct extract_iterator< C , typename boost::range_detail::exists< typename C::iterator >::type > { typedef typename C::iterator type; };
+    }
+    template< typename C >
+    struct range_mutable_iterator : range_detail::extract_iterator<C>
+    {};
+    template< typename Iterator >
+    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+    template< typename T, std::size_t sz >
+    struct range_mutable_iterator< T[sz] >
+    {
+        typedef T* type;
+    };
+}
+namespace boost
+{
+    namespace range_detail {
+        template< typename C, typename Enable=void > struct extract_const_iterator {}; template< typename C > struct extract_const_iterator< C , typename boost::range_detail::exists< typename C::const_iterator >::type > { typedef typename C::const_iterator type; };
+    }
+    template< typename C >
+    struct range_const_iterator : range_detail::extract_const_iterator<C>
+    {};
+    template< typename Iterator >
+    struct range_const_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+    template< typename T, std::size_t sz >
+    struct range_const_iterator< T[sz] >
+    {
+        typedef const T* type;
+    };
+}
+namespace boost
+{
+    template< typename C >
+    struct range_iterator
+    {
+        typedef typename
+            mpl::eval_if_c< is_const<C>::value,
+                            range_const_iterator< typename remove_const<C>::type >,
+                            range_mutable_iterator<C> >::type type;
+    };
+}
+namespace boost
+{
+namespace range_detail
+{
+        template< typename C >
+        inline typename range_iterator<C>::type
+        range_end( C& c )
+        {
+            return c.end();
+        }
+        template< typename Iterator >
+        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+        template< typename Iterator >
+        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+        template< typename T, std::size_t sz >
+        inline const T* range_end( const T (&a)[sz] )
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+        template< typename T, std::size_t sz >
+        inline T* range_end( T (&a)[sz] )
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+}
+namespace range_adl_barrier
+{
+template< class T >
+inline typename range_iterator<T>::type end( T& r )
+{
+    using namespace range_detail;
+    return range_end( r );
+}
+template< class T >
+inline typename range_iterator<const T>::type end( const T& r )
+{
+    using namespace range_detail;
+    return range_end( r );
+}
+    }
+}
+namespace boost
+{
+    namespace range_adl_barrier
+    {
+        template< class T >
+        inline typename range_iterator<const T>::type
+        const_end( const T& r )
+        {
+            return boost::range_adl_barrier::end( r );
+        }
+    }
+    using namespace range_adl_barrier;
+}
+namespace boost
+{
+namespace range_detail
+{
+    template< typename C >
+    inline typename range_iterator<C>::type
+    range_begin( C& c )
+    {
+        return c.begin();
+    }
+    template< typename Iterator >
+    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+    template< typename Iterator >
+    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+    template< typename T, std::size_t sz >
+    inline const T* range_begin( const T (&a)[sz] )
+    {
+        return a;
+    }
+    template< typename T, std::size_t sz >
+    inline T* range_begin( T (&a)[sz] )
+    {
+        return a;
+    }
+}
+namespace range_adl_barrier
+{
+template< class T >
+inline typename range_iterator<T>::type begin( T& r )
+{
+    using namespace range_detail;
+    return range_begin( r );
+}
+template< class T >
+inline typename range_iterator<const T>::type begin( const T& r )
+{
+    using namespace range_detail;
+    return range_begin( r );
+}
+    }
+}
+namespace boost
+{
+    namespace range_adl_barrier
+    {
+        template< class T >
+        inline typename range_iterator<const T>::type
+        const_begin( const T& r )
+        {
+            return boost::range_adl_barrier::begin( r );
+        }
+    }
+    using namespace range_adl_barrier;
+}
+namespace boost
+{
+  namespace detail {
+   template <class Category, class T, class Distance, class Pointer, class Reference>
+   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
+  }
+  template <class Category, class T, class Distance = std::ptrdiff_t,
+            class Pointer = T*, class Reference = T&>
+  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+}
+namespace boost
+{
+template < typename MemberType, int UniqueID = 0 >
+class base_from_member
+{
+protected:
+    MemberType member;
+    base_from_member()
+        : member()
+        {}
+ template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {} template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}
+};
+}
+namespace boost {
+template <class T>
+inline T next(T x) { return ++x; }
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+    std::advance(x, n);
+    return x;
+}
+template <class T>
+inline T prior(T x) { return --x; }
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+    std::advance(x, -n);
+    return x;
+}
+}
+namespace boost {
+struct no_traversal_tag {};
+struct incrementable_traversal_tag
+  : no_traversal_tag
+{
+};
+struct single_pass_traversal_tag
+  : incrementable_traversal_tag
+{
+};
+struct forward_traversal_tag
+  : single_pass_traversal_tag
+{
+};
+struct bidirectional_traversal_tag
+  : forward_traversal_tag
+{
+};
+struct random_access_traversal_tag
+  : bidirectional_traversal_tag
+{
+};
+namespace detail
+{
+  template <class Cat>
+  struct old_category_to_traversal
+    : mpl::eval_if<
+          is_convertible<Cat,std::random_access_iterator_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Cat,std::bidirectional_iterator_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Cat,std::forward_iterator_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Cat,std::input_iterator_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Cat,std::output_iterator_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {};
+  template <class Traversal>
+  struct pure_traversal_tag
+    : mpl::eval_if<
+          is_convertible<Traversal,random_access_traversal_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Traversal,bidirectional_traversal_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Traversal,forward_traversal_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Traversal,single_pass_traversal_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Traversal,incrementable_traversal_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {
+  };
+}
+template <class Cat>
+struct iterator_category_to_traversal
+  : mpl::eval_if<
+        is_convertible<Cat,incrementable_traversal_tag>
+      , mpl::identity<Cat>
+      , boost::detail::old_category_to_traversal<Cat>
+    >
+{};
+template <class Iterator = mpl::_1>
+struct iterator_traversal
+  : iterator_category_to_traversal<
+        typename boost::detail::iterator_traits<Iterator>::iterator_category
+    >
+{};
+}
+namespace boost
+{
+  template <typename A, typename B>
+  struct is_interoperable
+    : mpl::or_<
+          is_convertible< A, B >
+        , is_convertible< B, A > >
+  {
+  };
+}
+namespace boost { namespace detail {
+namespace indirect_traits {
+template <class T>
+struct is_reference_to_const : mpl::false_
+{
+};
+template <class T>
+struct is_reference_to_const<T const&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_function : mpl::false_
+{
+};
+template <class T>
+struct is_reference_to_function<T&> : is_function<T>
+{
+};
+template <class T>
+struct is_pointer_to_function : mpl::false_
+{
+};
+template <class T>
+struct is_pointer_to_function<T*> : is_function<T>
+{
+};
+template <class T>
+struct is_reference_to_member_function_pointer_impl : mpl::false_
+{
+};
+template <class T>
+struct is_reference_to_member_function_pointer_impl<T&>
+    : is_member_function_pointer<typename remove_cv<T>::type>
+{
+};
+template <class T>
+struct is_reference_to_member_function_pointer
+    : is_reference_to_member_function_pointer_impl<T>
+{
+};
+template <class T>
+struct is_reference_to_function_pointer_aux
+    : mpl::and_<
+          is_reference<T>
+        , is_pointer_to_function<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >
+      >
+{
+};
+template <class T>
+struct is_reference_to_function_pointer
+    : mpl::if_<
+          is_reference_to_function<T>
+        , mpl::false_
+        , is_reference_to_function_pointer_aux<T>
+     >::type
+{
+};
+template <class T>
+struct is_reference_to_non_const
+    : mpl::and_<
+          is_reference<T>
+        , mpl::not_<
+             is_reference_to_const<T>
+          >
+      >
+{
+};
+template <class T>
+struct is_reference_to_volatile : mpl::false_
+{
+};
+template <class T>
+struct is_reference_to_volatile<T volatile&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_pointer : mpl::false_
+{
+};
+template <class T>
+struct is_reference_to_pointer<T*&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_pointer<T* const&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_pointer<T* volatile&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+{
+};
+template <class T>
+struct is_reference_to_class
+    : mpl::and_<
+          is_reference<T>
+        , is_class<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >
+      >
+{
+};
+template <class T>
+struct is_pointer_to_class
+    : mpl::and_<
+          is_pointer<T>
+        , is_class<
+              typename remove_cv<
+                  typename remove_pointer<T>::type
+              >::type
+          >
+      >
+{
+};
+}
+using namespace indirect_traits;
+}}
+namespace boost { struct use_default; }
+namespace boost { namespace detail {
+struct input_output_iterator_tag
+  : std::input_iterator_tag
+{
+    operator std::output_iterator_tag() const
+    {
+        return std::output_iterator_tag();
+    }
+};
+template <class ValueParam, class Reference>
+struct iterator_writability_disabled
+  : mpl::or_<
+        is_const<Reference>
+      , boost::detail::indirect_traits::is_reference_to_const<Reference>
+      , is_const<ValueParam>
+    >
+{};
+template <class Traversal, class ValueParam, class Reference>
+struct iterator_facade_default_category
+  : mpl::eval_if<
+        mpl::and_<
+            is_reference<Reference>
+          , is_convertible<Traversal,forward_traversal_tag>
+        >
+      , mpl::eval_if<
+            is_convertible<Traversal,random_access_traversal_tag>
+          , mpl::identity<std::random_access_iterator_tag>
+          , mpl::if_<
+                is_convertible<Traversal,bidirectional_traversal_tag>
+              , std::bidirectional_iterator_tag
+              , std::forward_iterator_tag
+            >
+        >
+      , typename mpl::eval_if<
+            mpl::and_<
+                is_convertible<Traversal, single_pass_traversal_tag>
+              , is_convertible<Reference, ValueParam>
+            >
+          , mpl::identity<std::input_iterator_tag>
+          , mpl::identity<Traversal>
+        >
+    >
+{
+};
+template <class T>
+struct is_iterator_category
+  : mpl::or_<
+        is_convertible<T,std::input_iterator_tag>
+      , is_convertible<T,std::output_iterator_tag>
+    >
+{
+};
+template <class T>
+struct is_iterator_traversal
+  : is_convertible<T,incrementable_traversal_tag>
+{};
+template <class Category, class Traversal>
+struct iterator_category_with_traversal
+  : Category, Traversal
+{
+    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }
+             ;
+    enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_153 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };
+};
+template <class Traversal, class ValueParam, class Reference>
+struct facade_iterator_category_impl
+{
+    enum { mpl_assertion_in_line_166 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+    typedef typename iterator_facade_default_category<
+        Traversal,ValueParam,Reference
+    >::type category;
+    typedef typename mpl::if_<
+        is_same<
+            Traversal
+          , typename iterator_category_to_traversal<category>::type
+        >
+      , category
+      , iterator_category_with_traversal<category,Traversal>
+    >::type type;
+};
+template <class CategoryOrTraversal, class ValueParam, class Reference>
+struct facade_iterator_category
+  : mpl::eval_if<
+        is_iterator_category<CategoryOrTraversal>
+      , mpl::identity<CategoryOrTraversal>
+      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
+    >
+{
+};
+}}
+namespace boost
+{
+  namespace iterators
+  {
+    template<bool>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+      };
+    };
+    template <class Cond,
+              class Return>
+    struct enable_if
+      : enabled<(Cond::value)>::template base<Return>
+    {
+    };
+  }
+}
+namespace boost {
+template <typename T>
+inline T implicit_cast (typename mpl::identity<T>::type x) {
+    return x;
+}
+}
+namespace boost {
+namespace detail {
+template <typename T>
+struct add_pointer_impl
+{
+    typedef typename remove_reference<T>::type no_ref_type;
+    typedef no_ref_type* type;
+};
+}
+template< typename T > struct add_pointer { public: typedef typename boost::detail::add_pointer_impl<T>::type type; };
+}
+namespace boost
+{
+  template <class I, class V, class TC, class R, class D> class iterator_facade;
+  namespace detail
+  {
+    struct always_bool2
+    {
+        template <class T, class U>
+        struct apply
+        {
+            typedef bool type;
+        };
+    };
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable
+      : ::boost::iterators::enable_if<
+           mpl::or_<
+               is_convertible<Facade1, Facade2>
+             , is_convertible<Facade2, Facade1>
+           >
+         , Return
+        >
+    {};
+    template <
+        class ValueParam
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_facade_types
+    {
+        typedef typename facade_iterator_category<
+            CategoryOrTraversal, ValueParam, Reference
+        >::type iterator_category;
+        typedef typename remove_const<ValueParam>::type value_type;
+        typedef typename mpl::eval_if<
+            boost::detail::iterator_writability_disabled<ValueParam,Reference>
+          , add_pointer<const value_type>
+          , add_pointer<value_type>
+        >::type pointer;
+    };
+    template <class Iterator>
+    class postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+        {}
+        value_type&
+        operator*() const
+        {
+            return this->stored_value;
+        }
+     private:
+        mutable value_type stored_value;
+    };
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+          , stored_iterator(x)
+        {}
+        writable_postfix_increment_proxy const&
+        operator*() const
+        {
+            return *this;
+        }
+        operator value_type&() const
+        {
+            return stored_value;
+        }
+        template <class T>
+        T const& operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+        template <class T>
+        T& operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+        operator Iterator const&() const
+        {
+            return stored_iterator;
+        }
+     private:
+        mutable value_type stored_value;
+        Iterator stored_iterator;
+    };
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : is_convertible<
+            typename remove_reference<Reference>::type
+            const volatile*
+          , Value const volatile*
+        >
+    {};
+    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+    struct postfix_increment_result
+      : mpl::eval_if<
+            mpl::and_<
+                is_convertible<Reference,Value const&>
+              , mpl::not_<
+                    is_convertible<
+                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
+                      , forward_traversal_tag
+                    >
+                >
+            >
+          , mpl::if_<
+                is_non_proxy_reference<Reference,Value>
+              , postfix_increment_proxy<Iterator>
+              , writable_postfix_increment_proxy<Iterator>
+            >
+          , mpl::identity<Iterator>
+        >
+    {};
+    template <class T>
+    struct operator_arrow_proxy
+    {
+        operator_arrow_proxy(T const* px) : m_value(*px) {}
+        T* operator->() const { return &m_value; }
+        operator T*() const { return &m_value; }
+        mutable T m_value;
+    };
+    template <class ValueType, class Reference, class Pointer>
+    struct operator_arrow_result
+    {
+        typedef typename mpl::if_<
+            is_reference<Reference>
+          , Pointer
+          , operator_arrow_proxy<ValueType>
+        >::type type;
+        static type make(Reference x)
+        {
+            return boost::implicit_cast<type>(&x);
+        }
+    };
+    template <class Iterator>
+    class operator_brackets_proxy
+    {
+        typedef typename Iterator::reference reference;
+        typedef typename Iterator::value_type value_type;
+     public:
+        operator_brackets_proxy(Iterator const& iter)
+          : m_iter(iter)
+        {}
+        operator reference() const
+        {
+            return *m_iter;
+        }
+        operator_brackets_proxy& operator=(value_type const& val)
+        {
+            *m_iter = val;
+            return *this;
+        }
+     private:
+        Iterator m_iter;
+    };
+    template <class ValueType, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::not_<
+            mpl::and_<
+                boost::is_POD<ValueType>
+              , iterator_writability_disabled<ValueType,Reference>
+            >
+        >
+    {};
+    template <class Iterator, class Value, class Reference>
+    struct operator_brackets_result
+    {
+        typedef typename mpl::if_<
+            use_operator_brackets_proxy<Value,Reference>
+          , operator_brackets_proxy<Iterator>
+          , Value
+        >::type type;
+    };
+    template <class Iterator>
+    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
+    {
+        return operator_brackets_proxy<Iterator>(iter);
+    }
+    template <class Iterator>
+    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
+    {
+      return *iter;
+    }
+    struct choose_difference_type
+    {
+        template <class I1, class I2>
+        struct apply
+          :
+          mpl::eval_if<
+              is_convertible<I2,I1>
+            , iterator_difference<I1>
+            , iterator_difference<I2>
+          >
+        {};
+    };
+  }
+  class iterator_core_access
+  {
+      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+      ;
+      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)
+      ;
+      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)
+      ;
+      template <class Facade>
+      static typename Facade::reference dereference(Facade const& f)
+      {
+          return f.dereference();
+      }
+      template <class Facade>
+      static void increment(Facade& f)
+      {
+          f.increment();
+      }
+      template <class Facade>
+      static void decrement(Facade& f)
+      {
+          f.decrement();
+      }
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return f1.equal(f2);
+      }
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.equal(f1);
+      }
+      template <class Facade>
+      static void advance(Facade& f, typename Facade::difference_type n)
+      {
+          f.advance(n);
+      }
+      template <class Facade1, class Facade2>
+      static typename Facade1::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return -f1.distance_to(f2);
+      }
+      template <class Facade1, class Facade2>
+      static typename Facade2::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.distance_to(f1);
+      }
+      template <class I, class V, class TC, class R, class D>
+      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
+      {
+          return *static_cast<I*>(&facade);
+      }
+      template <class I, class V, class TC, class R, class D>
+      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
+      {
+          return *static_cast<I const*>(&facade);
+      }
+   private:
+      iterator_core_access();
+  };
+  template <
+      class Derived
+    , class Value
+    , class CategoryOrTraversal
+    , class Reference = Value&
+    , class Difference = std::ptrdiff_t
+  >
+  class iterator_facade
+  {
+   private:
+      Derived& derived()
+      {
+          return *static_cast<Derived*>(this);
+      }
+      Derived const& derived() const
+      {
+          return *static_cast<Derived const*>(this);
+      }
+      typedef boost::detail::iterator_facade_types<
+         Value, CategoryOrTraversal, Reference, Difference
+      > associated_types;
+      typedef boost::detail::operator_arrow_result<
+        typename associated_types::value_type
+        , Reference
+        , typename associated_types::pointer
+      > pointer_;
+   protected:
+      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
+   public:
+      typedef typename associated_types::value_type value_type;
+      typedef Reference reference;
+      typedef Difference difference_type;
+      typedef typename pointer_::type pointer;
+      typedef typename associated_types::iterator_category iterator_category;
+      reference operator*() const
+      {
+          return iterator_core_access::dereference(this->derived());
+      }
+      pointer operator->() const
+      {
+          return pointer_::make(*this->derived());
+      }
+      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
+      operator[](difference_type n) const
+      {
+          typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
+          return boost::detail::make_operator_brackets_result<Derived>(
+              this->derived() + n
+            , use_proxy()
+          );
+      }
+      Derived& operator++()
+      {
+          iterator_core_access::increment(this->derived());
+          return this->derived();
+      }
+      Derived& operator--()
+      {
+          iterator_core_access::decrement(this->derived());
+          return this->derived();
+      }
+      Derived operator--(int)
+      {
+          Derived tmp(this->derived());
+          --*this;
+          return tmp;
+      }
+      Derived& operator+=(difference_type n)
+      {
+          iterator_core_access::advance(this->derived(), n);
+          return this->derived();
+      }
+      Derived& operator-=(difference_type n)
+      {
+          iterator_core_access::advance(this->derived(), -n);
+          return this->derived();
+      }
+      Derived operator-(difference_type x) const
+      {
+          Derived result(this->derived());
+          return result -= x;
+      }
+  };
+  template <class I, class V, class TC, class R, class D>
+  inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+  operator++(
+      iterator_facade<I,V,TC,R,D>& i
+    , int
+  )
+  {
+      typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+          tmp(*static_cast<I*>(&i));
+      ++i;
+      return tmp;
+  }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_836; return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_837; return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_839; return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_840; return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_841; return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_842; return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)>
+ boost_static_assert_typedef_851
+  ; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+}
+namespace boost
+{
+  struct use_default;
+  template<class To>
+  struct is_convertible<use_default,To>
+    : mpl::false_ {};
+  namespace detail
+  {
+    struct enable_type;
+  }
+  template<typename From, typename To>
+  struct enable_if_convertible
+    : iterators::enable_if<
+          is_convertible<From, To>
+        , boost::detail::enable_type
+      >
+  {};
+  namespace detail
+  {
+    template <class T, class DefaultNullaryFn>
+    struct ia_dflt_help
+      : mpl::eval_if<
+            is_same<T, use_default>
+          , DefaultNullaryFn
+          , mpl::identity<T>
+        >
+    {
+    };
+    template <
+        class Derived
+      , class Base
+      , class Value
+      , class Traversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_adaptor_base
+    {
+        typedef iterator_facade<
+            Derived
+          , typename boost::detail::ia_dflt_help<
+                Value
+              , mpl::eval_if<
+                    is_same<Reference,use_default>
+                  , iterator_value<Base>
+                  , remove_reference<Reference>
+                >
+            >::type
+          , typename boost::detail::ia_dflt_help<
+                Traversal
+              , iterator_traversal<Base>
+            >::type
+          , typename boost::detail::ia_dflt_help<
+                Reference
+              , mpl::eval_if<
+                    is_same<Value,use_default>
+                  , iterator_reference<Base>
+                  , add_reference<Value>
+                >
+            >::type
+          , typename boost::detail::ia_dflt_help<
+                Difference, iterator_difference<Base>
+            >::type
+        >
+        type;
+    };
+    template <class Tr1, class Tr2>
+    inline void iterator_adaptor_assert_traversal ()
+    {
+      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Tr1, Tr2>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_224;
+    }
+  }
+  template <
+      class Derived
+    , class Base
+    , class Value = use_default
+    , class Traversal = use_default
+    , class Reference = use_default
+    , class Difference = use_default
+  >
+  class iterator_adaptor
+    : public boost::detail::iterator_adaptor_base<
+        Derived, Base, Value, Traversal, Reference, Difference
+      >::type
+  {
+      friend class iterator_core_access;
+   protected:
+      typedef typename boost::detail::iterator_adaptor_base<
+          Derived, Base, Value, Traversal, Reference, Difference
+      >::type super_t;
+   public:
+      iterator_adaptor() {}
+      explicit iterator_adaptor(Base const &iter)
+          : m_iterator(iter)
+      {
+      }
+      typedef Base base_type;
+      Base const& base() const
+        { return m_iterator; }
+   protected:
+      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
+      Base const& base_reference() const
+        { return m_iterator; }
+      Base& base_reference()
+        { return m_iterator; }
+   private:
+      typename super_t::reference dereference() const
+        { return *m_iterator; }
+      template <
+      class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
+      {
+          return m_iterator == x.base();
+      }
+      typedef typename iterator_category_to_traversal<
+          typename super_t::iterator_category
+      >::type my_traversal;
+      void advance(typename super_t::difference_type n)
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
+          m_iterator += n;
+      }
+      void increment() { ++m_iterator; }
+      void decrement()
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
+           --m_iterator;
+      }
+      template <
+          class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      typename super_t::difference_type distance_to(
+          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
+          return y.base() - m_iterator;
+      }
+   private:
+      Base m_iterator;
+  };
+}
+namespace boost
+{
+  template <class Iterator>
+  class reverse_iterator
+      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
+  {
+      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
+      friend class iterator_core_access;
+   public:
+      reverse_iterator() {}
+      explicit reverse_iterator(Iterator x)
+          : super_t(x) {}
+      template<class OtherIterator>
+      reverse_iterator(
+          reverse_iterator<OtherIterator> const& r
+          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+          )
+          : super_t(r.base())
+      {}
+   private:
+      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+      void increment() { --this->base_reference(); }
+      void decrement() { ++this->base_reference(); }
+      void advance(typename super_t::difference_type n)
+      {
+          this->base_reference() += -n;
+      }
+      template <class OtherIterator>
+      typename super_t::difference_type
+      distance_to(reverse_iterator<OtherIterator> const& y) const
+      {
+          return this->base_reference() - y.base();
+      }
+  };
+  template <class BidirectionalIterator>
+  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+  {
+      return reverse_iterator<BidirectionalIterator>(x);
+  }
+}
+namespace boost
+{
+    template< typename C >
+    struct range_reverse_iterator
+    {
+        typedef reverse_iterator<
+            typename range_iterator<C>::type > type;
+    };
+}
+namespace boost
+{
+template< class C >
+inline typename range_reverse_iterator<C>::type
+rend( C& c )
+{
+    typedef typename range_reverse_iterator<C>::type
+               iter_type;
+    return iter_type( boost::begin( c ) );
+}
+template< class C >
+inline typename range_reverse_iterator<const C>::type
+rend( const C& c )
+{
+    typedef typename range_reverse_iterator<const C>::type
+        iter_type;
+    return iter_type( boost::begin( c ) );
+}
+template< class T >
+inline typename range_reverse_iterator<const T>::type
+const_rend( const T& r )
+{
+    return boost::rend( r );
+}
+}
+namespace boost
+{
+template< class C >
+inline typename range_reverse_iterator<C>::type
+rbegin( C& c )
+{
+    typedef typename range_reverse_iterator<C>::type
+        iter_type;
+    return iter_type( boost::end( c ) );
+}
+template< class C >
+inline typename range_reverse_iterator<const C>::type
+rbegin( const C& c )
+{
+    typedef typename range_reverse_iterator<const C>::type
+        iter_type;
+    return iter_type( boost::end( c ) );
+}
+template< class T >
+inline typename range_reverse_iterator<const T>::type
+const_rbegin( const T& r )
+{
+    return boost::rbegin( r );
+}
+}
+enum boost_foreach_argument_dependent_lookup_hack
+{
+    boost_foreach_argument_dependent_lookup_hack_value
+};
+namespace boost
+{
+namespace
+                    Q_FOREACH
+{
+    template<typename T>
+    std::pair<T, T> in_range(T begin, T end);
+    typedef boost_foreach_argument_dependent_lookup_hack tag;
+    template<typename T>
+    struct is_lightweight_proxy;
+    template<typename T>
+    struct is_noncopyable;
+}
+namespace BOOST_FOREACH
+{
+    using
+                    Q_FOREACH
+                 ::in_range;
+    using
+                    Q_FOREACH
+                 ::tag;
+    template<typename T>
+    struct is_lightweight_proxy
+      :
+                    Q_FOREACH
+               ::is_lightweight_proxy<T>
+    {};
+    template<typename T>
+    struct is_noncopyable
+      :
+                    Q_FOREACH
+               ::is_noncopyable<T>
+    {};
+}
+}
+namespace boost
+{
+template<typename T>
+class iterator_range;
+template<typename T>
+class sub_range;
+namespace
+                    Q_FOREACH
+{
+    template<typename T>
+    inline std::pair<T, T> in_range(T begin, T end)
+    {
+        return std::make_pair(begin, end);
+    }
+    template<typename T>
+    struct is_lightweight_proxy
+      : boost::mpl::false_
+    {
+    };
+    template<typename T>
+    struct is_noncopyable
+      : boost::mpl::or_<
+            boost::is_abstract<T>
+          , boost::is_base_and_derived<boost::noncopyable, T>
+        >
+    {
+    };
+}
+}
+template<typename T>
+inline boost::BOOST_FOREACH::is_lightweight_proxy<T> *
+boost_foreach_is_lightweight_proxy(T *&, boost::
+                    Q_FOREACH
+                                         ::tag) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::
+                    Q_FOREACH
+                                                                     ::tag) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::
+                    Q_FOREACH
+                                                                              ::tag) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::
+                    Q_FOREACH
+                                                                         ::tag) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(T **&, boost::
+                    Q_FOREACH
+                                                        ::tag) { return 0; }
+template<typename T>
+inline boost::BOOST_FOREACH::is_noncopyable<T> *
+boost_foreach_is_noncopyable(T *&, boost::
+                    Q_FOREACH
+                                   ::tag) { return 0; }
+namespace boost
+{
+namespace foreach_detail_
+{
+template<typename Bool1, typename Bool2>
+inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }
+template<typename Bool1, typename Bool2, typename Bool3>
+inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
+template<typename Bool1, typename Bool2>
+inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }
+template<typename Bool1, typename Bool2, typename Bool3>
+inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
+template<typename Bool1>
+inline boost::mpl::not_<Bool1> *not_(Bool1 *) { return 0; }
+template<typename T>
+inline boost::is_array<T> *is_array_(T const &) { return 0; }
+template<typename T>
+inline boost::is_const<T> *is_const_(T &) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *is_const_(T const &) { return 0; }
+template<typename T>
+inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }
+template<typename T>
+inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }
+struct auto_any_base
+{
+    operator bool() const
+    {
+        return false;
+    }
+};
+template<typename T>
+struct auto_any : auto_any_base
+{
+    explicit auto_any(T const &t)
+      : item(t)
+    {
+    }
+    mutable T item;
+};
+typedef auto_any_base const &auto_any_t;
+template<typename T, typename C>
+inline typename boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)
+{
+    return static_cast<auto_any<T> const &>(a).item;
+}
+typedef boost::mpl::true_ const_;
+template<typename T, typename C = boost::mpl::false_>
+struct type2type
+  : boost::mpl::if_<C, T const, T>
+{
+};
+template<typename T>
+struct wrap_cstr
+{
+    typedef T type;
+};
+template<>
+struct wrap_cstr<char *>
+{
+    typedef wrap_cstr<char *> type;
+    typedef char *iterator;
+    typedef char *const_iterator;
+};
+template<>
+struct wrap_cstr<char const *>
+{
+    typedef wrap_cstr<char const *> type;
+    typedef char const *iterator;
+    typedef char const *const_iterator;
+};
+template<>
+struct wrap_cstr<wchar_t *>
+{
+    typedef wrap_cstr<wchar_t *> type;
+    typedef wchar_t *iterator;
+    typedef wchar_t *const_iterator;
+};
+template<>
+struct wrap_cstr<wchar_t const *>
+{
+    typedef wrap_cstr<wchar_t const *> type;
+    typedef wchar_t const *iterator;
+    typedef wchar_t const *const_iterator;
+};
+template<typename T>
+struct is_char_array
+  : mpl::and_<
+        is_array<T>
+      , mpl::or_<
+            is_convertible<T, char const *>
+          , is_convertible<T, wchar_t const *>
+        >
+    >
+{};
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_iterator
+{
+    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING353 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg353; enum { mpl_assertion_in_line_353 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg353::assert_arg() ) ) };
+    typedef typename wrap_cstr<T>::type container;
+    typedef typename boost::mpl::eval_if<
+        C
+      , range_const_iterator<container>
+      , range_mutable_iterator<container>
+    >::type type;
+};
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_reverse_iterator
+{
+    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING384 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg384; enum { mpl_assertion_in_line_384 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg384::assert_arg() ) ) };
+    typedef typename wrap_cstr<T>::type container;
+    typedef typename boost::mpl::eval_if<
+        C
+      , range_reverse_iterator<container const>
+      , range_reverse_iterator<container>
+    >::type type;
+};
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_reference
+  : iterator_reference<typename foreach_iterator<T, C>::type>
+{
+};
+template<typename T>
+inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }
+template<typename T>
+inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }
+inline bool set_false(bool &b)
+{
+    b = false;
+    return false;
+}
+template<typename T>
+inline T *&to_ptr(T const &)
+{
+    static T *t = 0;
+    return t;
+}
+template<typename T>
+inline T &derefof(T *t)
+{
+    return reinterpret_cast<T &>(
+        *const_cast<char *>(
+            reinterpret_cast<char const volatile *>(t)
+        )
+    );
+}
+template<typename T>
+struct rvalue_probe
+{
+    rvalue_probe(T &t, bool &b)
+      : value(t)
+      , is_rvalue(b)
+    {
+    }
+    struct private_type_ {};
+    typedef typename boost::mpl::if_<
+        boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T
+    >::type value_type;
+    operator value_type()
+    {
+        this->is_rvalue = true;
+        return this->value;
+    }
+    operator T &() const
+    {
+        return this->value;
+    }
+private:
+    T &value;
+    bool &is_rvalue;
+};
+template<typename T>
+rvalue_probe<T> make_probe(T &t, bool &b) { return rvalue_probe<T>(t, b); }
+template<typename T>
+rvalue_probe<T const> make_probe(T const &t, bool &b) { return rvalue_probe<T const>(t, b); }
+template<typename T>
+struct simple_variant
+{
+    simple_variant(T const *t)
+      : is_rvalue(false)
+    {
+        *static_cast<T const **>(this->data.address()) = t;
+    }
+    simple_variant(T const &t)
+      : is_rvalue(true)
+    {
+        ::new(this->data.address()) T(t);
+    }
+    simple_variant(simple_variant const &that)
+      : is_rvalue(that.is_rvalue)
+    {
+        if(this->is_rvalue)
+            ::new(this->data.address()) T(*that.get());
+        else
+            *static_cast<T const **>(this->data.address()) = that.get();
+    }
+    ~simple_variant()
+    {
+        if(this->is_rvalue)
+            this->get()->~T();
+    }
+    T const *get() const
+    {
+        if(this->is_rvalue)
+            return static_cast<T const *>(this->data.address());
+        else
+            return *static_cast<T const * const *>(this->data.address());
+    }
+private:
+    enum size_type { size = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*) };
+    simple_variant &operator =(simple_variant const &);
+    bool const is_rvalue;
+    aligned_storage<size> data;
+};
+template<typename LValue, typename IsProxy>
+inline typename boost::enable_if<boost::mpl::or_<LValue, IsProxy>, IsProxy>::type *
+should_copy_impl(LValue *, IsProxy *, bool *)
+{
+    return 0;
+}
+inline bool *
+should_copy_impl(boost::mpl::false_ *, boost::mpl::false_ *, bool *is_rvalue)
+{
+    return is_rvalue;
+}
+template<typename T>
+inline auto_any<T> contain(T const &t, boost::mpl::true_ *)
+{
+    return auto_any<T>(t);
+}
+template<typename T>
+inline auto_any<T *> contain(T &t, boost::mpl::false_ *)
+{
+    return auto_any<T *>(boost::addressof(t));
+}
+template<typename T>
+inline auto_any<simple_variant<T> >
+contain(T const &t, bool *rvalue)
+{
+    return auto_any<simple_variant<T> >(*rvalue ? simple_variant<T>(t) : simple_variant<T>(&t));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return auto_any<typename foreach_iterator<T, C>::type>(
+        boost::begin(auto_any_cast<T, C>(col)));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_iterator<T, C>::type iterator;
+    return auto_any<typename foreach_iterator<T, C>::type>(
+        iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
+}
+template<typename T>
+inline auto_any<typename foreach_iterator<T, const_>::type>
+begin(auto_any_t col, type2type<T, const_> *, bool *)
+{
+    return auto_any<typename foreach_iterator<T, const_>::type>(
+        boost::begin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
+}
+template<typename T, typename C>
+inline auto_any<T *>
+begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return auto_any<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return auto_any<typename foreach_iterator<T, C>::type>(
+        boost::end(auto_any_cast<T, C>(col)));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_iterator<T, C>::type iterator;
+    return auto_any<typename foreach_iterator<T, C>::type>(
+        iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
+}
+template<typename T>
+inline auto_any<typename foreach_iterator<T, const_>::type>
+end(auto_any_t col, type2type<T, const_> *, bool *)
+{
+    return auto_any<typename foreach_iterator<T, const_>::type>(
+        boost::end(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
+}
+template<typename T, typename C>
+inline auto_any<int>
+end(auto_any_t, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return auto_any<int>(0);
+}
+template<typename T, typename C>
+inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
+}
+template<typename T, typename C>
+inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *)
+{
+    return ! *auto_any_cast<T *, boost::mpl::false_>(cur);
+}
+template<typename T, typename C>
+inline void next(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+template<typename T, typename C>
+inline typename foreach_reference<T, C>::type
+deref(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return auto_any<typename foreach_reverse_iterator<T, C>::type>(
+        boost::rbegin(auto_any_cast<T, C>(col)));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_reverse_iterator<T, C>::type iterator;
+    return auto_any<typename foreach_reverse_iterator<T, C>::type>(
+        iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
+}
+template<typename T>
+inline auto_any<typename foreach_reverse_iterator<T, const_>::type>
+rbegin(auto_any_t col, type2type<T, const_> *, bool *)
+{
+    return auto_any<typename foreach_reverse_iterator<T, const_>::type>(
+        boost::rbegin(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
+}
+template<typename T, typename C>
+inline auto_any<reverse_iterator<T *> >
+rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    T *p = auto_any_cast<T *, boost::mpl::false_>(col);
+    while(0 != *p)
+        ++p;
+    return auto_any<reverse_iterator<T *> >(reverse_iterator<T *>(p));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return auto_any<typename foreach_reverse_iterator<T, C>::type>(
+        boost::rend(auto_any_cast<T, C>(col)));
+}
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_reverse_iterator<T, C>::type iterator;
+    return auto_any<typename foreach_reverse_iterator<T, C>::type>(
+        iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col)))));
+}
+template<typename T>
+inline auto_any<typename foreach_reverse_iterator<T, const_>::type>
+rend(auto_any_t col, type2type<T, const_> *, bool *)
+{
+    return auto_any<typename foreach_reverse_iterator<T, const_>::type>(
+        boost::rend(*auto_any_cast<simple_variant<T>, boost::mpl::false_>(col).get()));
+}
+template<typename T, typename C>
+inline auto_any<reverse_iterator<T *> >
+rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return auto_any<reverse_iterator<T *> >(
+        reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col)));
+}
+template<typename T, typename C>
+inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
+}
+template<typename T, typename C>
+inline void rnext(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+template<typename T, typename C>
+inline typename foreach_reference<T, C>::type
+rderef(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+}
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class logic_error : public exception
+  {
+    string _M_msg;
+  public:
+    explicit
+    logic_error(const string& __arg);
+    virtual ~logic_error() throw();
+    virtual const char*
+    what() const throw();
+  };
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg);
+    virtual ~domain_error() throw();
+  };
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg);
+    virtual ~invalid_argument() throw();
+  };
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg);
+    virtual ~length_error() throw();
+  };
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg);
+    virtual ~out_of_range() throw();
+  };
+  class runtime_error : public exception
+  {
+    string _M_msg;
+  public:
+    explicit
+    runtime_error(const string& __arg);
+    virtual ~runtime_error() throw();
+    virtual const char*
+    what() const throw();
+  };
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg);
+    virtual ~range_error() throw();
+  };
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg);
+    virtual ~overflow_error() throw();
+  };
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg);
+    virtual ~underflow_error() throw();
+  };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+    protected:
+      ios_base::openmode _M_mode;
+      __string_type _M_string;
+    public:
+      explicit
+      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
+      { _M_stringbuf_init(__mode); }
+      __string_type
+      str() const
+      {
+ __string_type __ret;
+ if (this->pptr())
+   {
+     if (this->pptr() > this->egptr())
+       __ret = __string_type(this->pbase(), this->pptr());
+     else
+        __ret = __string_type(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+      void
+      str(const __string_type& __s)
+      {
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+    protected:
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+      virtual int_type
+      underflow();
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+     _M_string.clear();
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+    };
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_istringstream(ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+      ~basic_istringstream()
+      { }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+      ~basic_ostringstream()
+      { }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+      ~basic_stringstream()
+      { }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+      const __size_type __capacity = _M_string.capacity();
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp;
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+   _M_update_egptr();
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->setg(this->eback(), this->eback() + __newoffi,
+    this->egptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       _M_pbump(this->pbase(), this->epptr(), __newoffo);
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->setg(this->eback(), this->eback() + __pos,
+      this->egptr());
+       if (__testout)
+  _M_pbump(this->pbase(), this->epptr(), __pos);
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+      if (__base != _M_string.data())
+ {
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   _M_pbump(__base, __endp, __o);
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+ {
+   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+   __off -= __gnu_cxx::__numeric_traits<int>::__max;
+ }
+      this->pbump(__off);
+    }
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+}
+namespace boost{
+namespace detail{
+static const ::boost::uint16_t high_surrogate_base = 0xD7C0u;
+static const ::boost::uint16_t low_surrogate_base = 0xDC00u;
+static const ::boost::uint32_t ten_bit_mask = 0x3FFu;
+inline bool is_high_surrogate(::boost::uint16_t v)
+{
+   return (v & 0xFFFFFC00u) == 0xd800u;
+}
+inline bool is_low_surrogate(::boost::uint16_t v)
+{
+   return (v & 0xFFFFFC00u) == 0xdc00u;
+}
+template <class T>
+inline bool is_surrogate(T v)
+{
+   return (v & 0xFFFFF800u) == 0xd800;
+}
+inline unsigned utf8_byte_count(boost::uint8_t c)
+{
+   boost::uint8_t mask = 0x80u;
+   unsigned result = 0;
+   while(c & mask)
+   {
+      ++result;
+      mask >>= 1;
+   }
+   return (result == 0) ? 1 : ((result > 4) ? 4 : result);
+}
+inline unsigned utf8_trailing_byte_count(boost::uint8_t c)
+{
+   return utf8_byte_count(c) - 1;
+}
+inline void invalid_utf32_code_point(::boost::uint32_t val)
+{
+   std::stringstream ss;
+   ss << "Invalid UTF-32 code point U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-16 sequence";
+   std::out_of_range e(ss.str());
+   boost::throw_exception(e);
+}
+}
+template <class BaseIterator, class U16Type = ::boost::uint16_t>
+class u32_to_u16_iterator
+   : public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>
+{
+   typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;
+   typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(base_value_type)*8 == 32) == 0 ? false : true) >)> boost_static_assert_typedef_147;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(U16Type)*8 == 16) == 0 ? false : true) >)> boost_static_assert_typedef_148;
+public:
+   typename base_type::reference
+      dereference()const
+   {
+      if(m_current == 2)
+         extract_current();
+      return m_values[m_current];
+   }
+   bool equal(const u32_to_u16_iterator& that)const
+   {
+      if(m_position == that.m_position)
+      {
+         return (m_current + that.m_current) & 1u ? false : true;
+      }
+      return false;
+   }
+   void increment()
+   {
+      if(m_current == 2)
+      {
+         extract_current();
+      }
+      ++m_current;
+      if(m_values[m_current] == 0)
+      {
+         m_current = 2;
+         ++m_position;
+      }
+   }
+   void decrement()
+   {
+      if(m_current != 1)
+      {
+         --m_position;
+         extract_current();
+         m_current = m_values[1] ? 1 : 0;
+      }
+      else
+      {
+         m_current = 0;
+      }
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+   u32_to_u16_iterator() : m_position(), m_current(0)
+   {
+      m_values[0] = 0;
+      m_values[1] = 0;
+      m_values[2] = 0;
+   }
+   u32_to_u16_iterator(BaseIterator b) : m_position(b), m_current(2)
+   {
+      m_values[0] = 0;
+      m_values[1] = 0;
+      m_values[2] = 0;
+   }
+private:
+   void extract_current()const
+   {
+      ::boost::uint32_t v = *m_position;
+      if(v >= 0x10000u)
+      {
+         if(v > 0x10FFFFu)
+            detail::invalid_utf32_code_point(*m_position);
+         m_values[0] = static_cast<U16Type>(v >> 10) + detail::high_surrogate_base;
+         m_values[1] = static_cast<U16Type>(v & detail::ten_bit_mask) + detail::low_surrogate_base;
+         m_current = 0;
+         (static_cast<void> (0));
+         (static_cast<void> (0));
+      }
+      else
+      {
+         m_values[0] = static_cast<U16Type>(*m_position);
+         m_values[1] = 0;
+         m_current = 0;
+         if(detail::is_surrogate(m_values[0]))
+            detail::invalid_utf32_code_point(*m_position);
+      }
+   }
+   BaseIterator m_position;
+   mutable U16Type m_values[3];
+   mutable unsigned m_current;
+};
+template <class BaseIterator, class U32Type = ::boost::uint32_t>
+class u16_to_u32_iterator
+   : public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
+{
+   typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
+   static const U32Type pending_read = 0xffffffffu;
+   typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(base_value_type)*8 == 16) == 0 ? false : true) >)> boost_static_assert_typedef_262;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(U32Type)*8 == 32) == 0 ? false : true) >)> boost_static_assert_typedef_263;
+public:
+   typename base_type::reference
+      dereference()const
+   {
+      if(m_value == pending_read)
+         extract_current();
+      return m_value;
+   }
+   bool equal(const u16_to_u32_iterator& that)const
+   {
+      return m_position == that.m_position;
+   }
+   void increment()
+   {
+      if(detail::is_high_surrogate(*m_position)) ++m_position;
+      ++m_position;
+      m_value = pending_read;
+   }
+   void decrement()
+   {
+      --m_position;
+      if(detail::is_low_surrogate(*m_position))
+         --m_position;
+      m_value = pending_read;
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+   u16_to_u32_iterator() : m_position()
+   {
+      m_value = pending_read;
+   }
+   u16_to_u32_iterator(BaseIterator b) : m_position(b)
+   {
+      m_value = pending_read;
+   }
+   u16_to_u32_iterator(BaseIterator b, BaseIterator start, BaseIterator end) : m_position(b)
+   {
+      m_value = pending_read;
+      boost::uint16_t val;
+      if(start != end)
+      {
+         if((b != start) && (b != end))
+         {
+            val = *b;
+            if(detail::is_surrogate(val) && ((val & 0xFC00u) == 0xDC00u))
+               invalid_code_point(val);
+         }
+         val = *start;
+         if(detail::is_surrogate(val) && ((val & 0xFC00u) == 0xDC00u))
+            invalid_code_point(val);
+         val = *--end;
+         if(detail::is_high_surrogate(val))
+            invalid_code_point(val);
+      }
+   }
+private:
+   static void invalid_code_point(::boost::uint16_t val)
+   {
+      std::stringstream ss;
+      ss << "Misplaced UTF-16 surrogate U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-32 sequence";
+      std::out_of_range e(ss.str());
+      boost::throw_exception(e);
+   }
+   void extract_current()const
+   {
+      m_value = static_cast<U32Type>(static_cast< ::boost::uint16_t>(*m_position));
+      if(detail::is_high_surrogate(*m_position))
+      {
+         BaseIterator next(m_position);
+         ::boost::uint16_t t = *++next;
+         if((t & 0xFC00u) != 0xDC00u)
+            invalid_code_point(t);
+         m_value = (m_value - detail::high_surrogate_base) << 10;
+         m_value |= (static_cast<U32Type>(static_cast< ::boost::uint16_t>(t)) & detail::ten_bit_mask);
+      }
+      if(detail::is_surrogate(m_value))
+         invalid_code_point(static_cast< ::boost::uint16_t>(m_value));
+   }
+   BaseIterator m_position;
+   mutable U32Type m_value;
+};
+template <class BaseIterator, class U8Type = ::boost::uint8_t>
+class u32_to_u8_iterator
+   : public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>
+{
+   typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;
+   typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(base_value_type)*8 == 32) == 0 ? false : true) >)> boost_static_assert_typedef_377;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(U8Type)*8 == 8) == 0 ? false : true) >)> boost_static_assert_typedef_378;
+public:
+   typename base_type::reference
+      dereference()const
+   {
+      if(m_current == 4)
+         extract_current();
+      return m_values[m_current];
+   }
+   bool equal(const u32_to_u8_iterator& that)const
+   {
+      if(m_position == that.m_position)
+      {
+         return (m_current == that.m_current)
+            || (((m_current | that.m_current) & 3) == 0);
+      }
+      return false;
+   }
+   void increment()
+   {
+      if(m_current == 4)
+      {
+         extract_current();
+      }
+      ++m_current;
+      if(m_values[m_current] == 0)
+      {
+         m_current = 4;
+         ++m_position;
+      }
+   }
+   void decrement()
+   {
+      if((m_current & 3) == 0)
+      {
+         --m_position;
+         extract_current();
+         m_current = 3;
+         while(m_current && (m_values[m_current] == 0))
+            --m_current;
+      }
+      else
+         --m_current;
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+   u32_to_u8_iterator() : m_position(), m_current(0)
+   {
+      m_values[0] = 0;
+      m_values[1] = 0;
+      m_values[2] = 0;
+      m_values[3] = 0;
+      m_values[4] = 0;
+   }
+   u32_to_u8_iterator(BaseIterator b) : m_position(b), m_current(4)
+   {
+      m_values[0] = 0;
+      m_values[1] = 0;
+      m_values[2] = 0;
+      m_values[3] = 0;
+      m_values[4] = 0;
+   }
+private:
+   void extract_current()const
+   {
+      boost::uint32_t c = *m_position;
+      if(c > 0x10FFFFu)
+         detail::invalid_utf32_code_point(c);
+      if(c < 0x80u)
+      {
+         m_values[0] = static_cast<unsigned char>(c);
+         m_values[1] = static_cast<unsigned char>(0u);
+         m_values[2] = static_cast<unsigned char>(0u);
+         m_values[3] = static_cast<unsigned char>(0u);
+      }
+      else if(c < 0x800u)
+      {
+         m_values[0] = static_cast<unsigned char>(0xC0u + (c >> 6));
+         m_values[1] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+         m_values[2] = static_cast<unsigned char>(0u);
+         m_values[3] = static_cast<unsigned char>(0u);
+      }
+      else if(c < 0x10000u)
+      {
+         m_values[0] = static_cast<unsigned char>(0xE0u + (c >> 12));
+         m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
+         m_values[2] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+         m_values[3] = static_cast<unsigned char>(0u);
+      }
+      else
+      {
+         m_values[0] = static_cast<unsigned char>(0xF0u + (c >> 18));
+         m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));
+         m_values[2] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
+         m_values[3] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+      }
+      m_current= 0;
+   }
+   BaseIterator m_position;
+   mutable U8Type m_values[5];
+   mutable unsigned m_current;
+};
+template <class BaseIterator, class U32Type = ::boost::uint32_t>
+class u8_to_u32_iterator
+   : public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>
+{
+   typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;
+   static const U32Type pending_read = 0xffffffffu;
+   typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(base_value_type)*8 == 8) == 0 ? false : true) >)> boost_static_assert_typedef_505;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(U32Type)*8 == 32) == 0 ? false : true) >)> boost_static_assert_typedef_506;
+public:
+   typename base_type::reference
+      dereference()const
+   {
+      if(m_value == pending_read)
+         extract_current();
+      return m_value;
+   }
+   bool equal(const u8_to_u32_iterator& that)const
+   {
+      return m_position == that.m_position;
+   }
+   void increment()
+   {
+      unsigned c = detail::utf8_byte_count(*m_position);
+      std::advance(m_position, c);
+      m_value = pending_read;
+   }
+   void decrement()
+   {
+      unsigned count = 0;
+      while((*--m_position & 0xC0u) == 0x80u) ++count;
+      if(count != detail::utf8_trailing_byte_count(*m_position))
+         invalid_sequence();
+      m_value = pending_read;
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+   u8_to_u32_iterator() : m_position()
+   {
+      m_value = pending_read;
+   }
+   u8_to_u32_iterator(BaseIterator b) : m_position(b)
+   {
+      m_value = pending_read;
+   }
+   u8_to_u32_iterator(BaseIterator b, BaseIterator start, BaseIterator end) : m_position(b)
+   {
+      m_value = pending_read;
+      if(start != end)
+      {
+         unsigned char v = *start;
+         if((v & 0xC0u) == 0x80u)
+            invalid_sequence();
+         if((b != start) && (b != end) && ((*b & 0xC0u) == 0x80u))
+            invalid_sequence();
+         BaseIterator pos = end;
+         do
+         {
+            v = *--pos;
+         }
+         while((start != pos) && ((v & 0xC0u) == 0x80u));
+         std::ptrdiff_t extra = detail::utf8_byte_count(v);
+         if(std::distance(pos, end) < extra)
+            invalid_sequence();
+      }
+   }
+private:
+   static void invalid_sequence()
+   {
+      std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");
+      boost::throw_exception(e);
+   }
+   void extract_current()const
+   {
+      m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));
+      if((m_value & 0xC0u) == 0x80u)
+         invalid_sequence();
+      unsigned extra = detail::utf8_trailing_byte_count(*m_position);
+      BaseIterator next(m_position);
+      for(unsigned c = 0; c < extra; ++c)
+      {
+         ++next;
+         m_value <<= 6;
+         m_value += static_cast<boost::uint8_t>(*next) & 0x3Fu;
+      }
+      static const boost::uint32_t masks[4] =
+      {
+         0x7Fu,
+         0x7FFu,
+         0xFFFFu,
+         0x1FFFFFu,
+      };
+      m_value &= masks[extra];
+      if(m_value > static_cast<U32Type>(0x10FFFFu))
+         invalid_sequence();
+   }
+   BaseIterator m_position;
+   mutable U32Type m_value;
+};
+template <class BaseIterator>
+class utf16_output_iterator
+{
+public:
+   typedef void difference_type;
+   typedef void value_type;
+   typedef boost::uint32_t* pointer;
+   typedef boost::uint32_t& reference;
+   typedef std::output_iterator_tag iterator_category;
+   utf16_output_iterator(const BaseIterator& b)
+      : m_position(b){}
+   utf16_output_iterator(const utf16_output_iterator& that)
+      : m_position(that.m_position){}
+   utf16_output_iterator& operator=(const utf16_output_iterator& that)
+   {
+      m_position = that.m_position;
+      return *this;
+   }
+   const utf16_output_iterator& operator*()const
+   {
+      return *this;
+   }
+   void operator=(boost::uint32_t val)const
+   {
+      push(val);
+   }
+   utf16_output_iterator& operator++()
+   {
+      return *this;
+   }
+   utf16_output_iterator& operator++(int)
+   {
+      return *this;
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+private:
+   void push(boost::uint32_t v)const
+   {
+      if(v >= 0x10000u)
+      {
+         if(v > 0x10FFFFu)
+            detail::invalid_utf32_code_point(v);
+         *m_position++ = static_cast<boost::uint16_t>(v >> 10) + detail::high_surrogate_base;
+         *m_position++ = static_cast<boost::uint16_t>(v & detail::ten_bit_mask) + detail::low_surrogate_base;
+      }
+      else
+      {
+         if(detail::is_surrogate(v))
+            detail::invalid_utf32_code_point(v);
+         *m_position++ = static_cast<boost::uint16_t>(v);
+      }
+   }
+   mutable BaseIterator m_position;
+};
+template <class BaseIterator>
+class utf8_output_iterator
+{
+public:
+   typedef void difference_type;
+   typedef void value_type;
+   typedef boost::uint32_t* pointer;
+   typedef boost::uint32_t& reference;
+   typedef std::output_iterator_tag iterator_category;
+   utf8_output_iterator(const BaseIterator& b)
+      : m_position(b){}
+   utf8_output_iterator(const utf8_output_iterator& that)
+      : m_position(that.m_position){}
+   utf8_output_iterator& operator=(const utf8_output_iterator& that)
+   {
+      m_position = that.m_position;
+      return *this;
+   }
+   const utf8_output_iterator& operator*()const
+   {
+      return *this;
+   }
+   void operator=(boost::uint32_t val)const
+   {
+      push(val);
+   }
+   utf8_output_iterator& operator++()
+   {
+      return *this;
+   }
+   utf8_output_iterator& operator++(int)
+   {
+      return *this;
+   }
+   BaseIterator base()const
+   {
+      return m_position;
+   }
+private:
+   void push(boost::uint32_t c)const
+   {
+      if(c > 0x10FFFFu)
+         detail::invalid_utf32_code_point(c);
+      if(c < 0x80u)
+      {
+         *m_position++ = static_cast<unsigned char>(c);
+      }
+      else if(c < 0x800u)
+      {
+         *m_position++ = static_cast<unsigned char>(0xC0u + (c >> 6));
+         *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+      }
+      else if(c < 0x10000u)
+      {
+         *m_position++ = static_cast<unsigned char>(0xE0u + (c >> 12));
+         *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
+         *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+      }
+      else
+      {
+         *m_position++ = static_cast<unsigned char>(0xF0u + (c >> 18));
+         *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));
+         *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));
+         *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));
+      }
+   }
+   mutable BaseIterator m_position;
+};
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct is_signed_values
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+template <class T>
+struct is_signed_helper
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
+};
+template <bool integral_type>
+struct is_signed_select_helper
+{
+   template <class T>
+   struct rebind
+   {
+      typedef is_signed_helper<T> type;
+   };
+};
+template <>
+struct is_signed_select_helper<false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+template <class T>
+struct is_signed_imp
+{
+   typedef is_signed_select_helper<
+      ::boost::type_traits::ice_or<
+         ::boost::is_integral<T>::value,
+         ::boost::is_enum<T>::value>::value
+   > selector;
+   typedef typename selector::template rebind<T> binder;
+   typedef typename binder::type type;
+   static const bool value = type::value;
+};
+}
+template< typename T > struct is_signed : public ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { public: };
+}
+namespace boost {
+namespace detail{
+template <class T>
+struct is_unsigned_values
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+template <class T>
+struct is_ununsigned_helper
+{
+   static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
+};
+template <bool integral_type>
+struct is_ununsigned_select_helper
+{
+   template <class T>
+   struct rebind
+   {
+      typedef is_ununsigned_helper<T> type;
+   };
+};
+template <>
+struct is_ununsigned_select_helper<false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+template <class T>
+struct is_unsigned_imp
+{
+   typedef is_ununsigned_select_helper<
+      ::boost::type_traits::ice_or<
+         ::boost::is_integral<T>::value,
+         ::boost::is_enum<T>::value>::value
+   > selector;
+   typedef typename selector::template rebind<T> binder;
+   typedef typename binder::type type;
+   static const bool value = type::value;
+};
+}
+template< typename T > struct is_unsigned : public ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { public: };
+}
+namespace boost {
+template< typename T > struct add_volatile { public: typedef T volatile type; };
+template< typename T > struct add_volatile<T&> { public: typedef T& type; };
+}
+namespace boost {
+namespace detail {
+template <class T>
+struct make_unsigned_imp
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_39;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_43;
+   typedef typename remove_cv<T>::type t_no_cv;
+   typedef typename mpl::if_c<
+      (::boost::type_traits::ice_and<
+         ::boost::is_unsigned<T>::value,
+         ::boost::is_integral<T>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+      T,
+      typename mpl::if_c<
+         (::boost::type_traits::ice_and<
+            ::boost::is_integral<T>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+         ::value),
+         typename mpl::if_<
+            is_same<t_no_cv, signed char>,
+            unsigned char,
+            typename mpl::if_<
+               is_same<t_no_cv, short>,
+               unsigned short,
+               typename mpl::if_<
+                  is_same<t_no_cv, int>,
+                  unsigned int,
+                  typename mpl::if_<
+                     is_same<t_no_cv, long>,
+                     unsigned long,
+                     boost::ulong_long_type
+                  >::type
+               >::type
+            >::type
+         >::type,
+         typename mpl::if_c<
+            sizeof(t_no_cv) == sizeof(unsigned char),
+            unsigned char,
+            typename mpl::if_c<
+               sizeof(t_no_cv) == sizeof(unsigned short),
+               unsigned short,
+               typename mpl::if_c<
+                  sizeof(t_no_cv) == sizeof(unsigned int),
+                  unsigned int,
+                  typename mpl::if_c<
+                     sizeof(t_no_cv) == sizeof(unsigned long),
+                     unsigned long,
+                     boost::ulong_long_type
+                  >::type
+               >::type
+            >::type
+         >::type
+      >::type
+   >::type base_integer_type;
+   typedef typename mpl::if_<
+      is_const<T>,
+      typename add_const<base_integer_type>::type,
+      base_integer_type
+   >::type const_base_integer_type;
+   typedef typename mpl::if_<
+      is_volatile<T>,
+      typename add_volatile<const_base_integer_type>::type,
+      const_base_integer_type
+   >::type type;
+};
+}
+template< typename T > struct make_unsigned { public: typedef typename boost::detail::make_unsigned_imp<T>::type type; };
+}
+namespace boost { namespace spirit
+{
+    typedef ::boost::uint32_t ucs4_char;
+    typedef char utf8_char;
+    typedef std::basic_string<ucs4_char> ucs4_string;
+    typedef std::basic_string<utf8_char> utf8_string;
+    template <typename Char>
+    inline utf8_string to_utf8(Char value)
+    {
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        *utf8_iter = (UChar)value;
+        return result;
+    }
+    template <typename Char>
+    inline utf8_string to_utf8(Char const* str)
+    {
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        while (*str)
+            *utf8_iter++ = (UChar)*str++;
+        return result;
+    }
+    template <typename Char, typename Traits, typename Allocator>
+    inline utf8_string
+    to_utf8(std::basic_string<Char, Traits, Allocator> const& str)
+    {
+        utf8_string result;
+        typedef std::back_insert_iterator<utf8_string> insert_iter;
+        insert_iter out_iter(result);
+        utf8_output_iterator<insert_iter> utf8_iter(out_iter);
+        typedef typename make_unsigned<Char>::type UChar;
+        if (bool _foreach_is_rvalue64 = false) {} else if (boost::foreach_detail_::auto_any_t _foreach_col64 = boost::foreach_detail_::contain( (true ? boost::foreach_detail_::make_probe((str), _foreach_is_rvalue64) : (str)) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(str) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(str))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue64)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_cur64 = boost::foreach_detail_::begin( _foreach_col64 , (true ? 0 : boost::foreach_detail_::encode_type(str, boost::foreach_detail_::is_const_(str))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(str) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(str))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue64)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_end64 = boost::foreach_detail_::end( _foreach_col64 , (true ? 0 : boost::foreach_detail_::encode_type(str, boost::foreach_detail_::is_const_(str))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(str) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(str))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(str) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue64)))) {} else for (bool _foreach_continue64 = true; _foreach_continue64 && !boost::foreach_detail_::done( _foreach_cur64 , _foreach_end64 , (true ? 0 : boost::foreach_detail_::encode_type(str, boost::foreach_detail_::is_const_(str)))); _foreach_continue64 ? boost::foreach_detail_::next( _foreach_cur64 , (true ? 0 : boost::foreach_detail_::encode_type(str, boost::foreach_detail_::is_const_(str)))) : (void)0) if (boost::foreach_detail_::set_false(_foreach_continue64)) {} else for (Char ch = boost::foreach_detail_::deref( _foreach_cur64 , (true ? 0 : boost::foreach_detail_::encode_type(str, boost::foreach_detail_::is_const_(str)))); !_foreach_continue64; _foreach_continue64 = true)
+        {
+            *utf8_iter++ = (UChar)ch;
+        }
+        return result;
+    }
+}}
+namespace boost { namespace spirit
+{
+    struct info
+    {
+        struct nil {};
+        typedef
+            boost::variant<
+                nil
+              , utf8_string
+              , recursive_wrapper<info>
+              , recursive_wrapper<std::pair<info, info> >
+              , std::list<info>
+            >
+        value_type;
+        explicit info(utf8_string const& tag)
+          : tag(tag), value(nil()) {}
+        template <typename T>
+        info(utf8_string const& tag, T const& value)
+          : tag(tag), value(value) {}
+        info(utf8_string const& tag, char value)
+          : tag(tag), value(utf8_string(1, value)) {}
+        info(utf8_string const& tag, wchar_t value)
+          : tag(tag), value(to_utf8(value)) {}
+        info(utf8_string const& tag, ucs4_char value)
+          : tag(tag), value(to_utf8(value)) {}
+        template <typename Char>
+        info(utf8_string const& tag, Char const* str)
+          : tag(tag), value(to_utf8(str)) {}
+        template <typename Char, typename Traits, typename Allocator>
+        info(utf8_string const& tag
+              , std::basic_string<Char, Traits, Allocator> const& str)
+          : tag(tag), value(to_utf8(str)) {}
+        utf8_string tag;
+        value_type value;
+    };
+    template <typename Callback>
+    struct basic_info_walker
+    {
+        typedef void result_type;
+        typedef basic_info_walker<Callback> this_type;
+        basic_info_walker(Callback& callback, utf8_string const& tag, int depth)
+          : callback(callback), tag(tag), depth(depth) {}
+        void operator()(info::nil) const
+        {
+            callback.element(tag, "", depth);
+        }
+        void operator()(utf8_string const& str) const
+        {
+            callback.element(tag, str, depth);
+        }
+        void operator()(info const& what) const
+        {
+            boost::apply_visitor(
+                this_type(callback, what.tag, depth+1), what.value);
+        }
+        void operator()(std::pair<info, info> const& pair) const
+        {
+            callback.element(tag, "", depth);
+            boost::apply_visitor(
+                this_type(callback, pair.first.tag, depth+1), pair.first.value);
+            boost::apply_visitor(
+                this_type(callback, pair.second.tag, depth+1), pair.second.value);
+        }
+        void operator()(std::list<info> const& l) const
+        {
+            callback.element(tag, "", depth);
+            if (bool _foreach_is_rvalue109 = false) {} else if (boost::foreach_detail_::auto_any_t _foreach_col109 = boost::foreach_detail_::contain( (true ? boost::foreach_detail_::make_probe((l), _foreach_is_rvalue109) : (l)) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(l) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(l))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue109)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_cur109 = boost::foreach_detail_::begin( _foreach_col109 , (true ? 0 : boost::foreach_detail_::encode_type(l, boost::foreach_detail_::is_const_(l))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(l) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(l))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue109)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_end109 = boost::foreach_detail_::end( _foreach_col109 , (true ? 0 : boost::foreach_detail_::encode_type(l, boost::foreach_detail_::is_const_(l))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(l) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(l))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(l) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue109)))) {} else for (bool _foreach_continue109 = true; _foreach_continue109 && !boost::foreach_detail_::done( _foreach_cur109 , _foreach_end109 , (true ? 0 : boost::foreach_detail_::encode_type(l, boost::foreach_detail_::is_const_(l)))); _foreach_continue109 ? boost::foreach_detail_::next( _foreach_cur109 , (true ? 0 : boost::foreach_detail_::encode_type(l, boost::foreach_detail_::is_const_(l)))) : (void)0) if (boost::foreach_detail_::set_false(_foreach_continue109)) {} else for (info const& what = boost::foreach_detail_::deref( _foreach_cur109 , (true ? 0 : boost::foreach_detail_::encode_type(l, boost::foreach_detail_::is_const_(l)))); !_foreach_continue109; _foreach_continue109 = true)
+            {
+                boost::apply_visitor(
+                    this_type(callback, what.tag, depth+1), what.value);
+            }
+        }
+        Callback& callback;
+        utf8_string const& tag;
+        int depth;
+    private:
+        basic_info_walker& operator= (basic_info_walker const&);
+    };
+    template <typename Out>
+    struct simple_printer
+    {
+        typedef utf8_string string;
+        simple_printer(Out& out)
+          : out(out) {}
+        void element(string const& tag, string const& value, int ) const
+        {
+            if (value == "")
+                out << '<' << tag << '>';
+            else
+                out << '"' << value << '"';
+        }
+        Out& out;
+    private:
+        simple_printer& operator= (simple_printer const&);
+    };
+    template <typename Out>
+    Out& operator<<(Out& out, info const& what)
+    {
+        simple_printer<Out> pr(out);
+        basic_info_walker<simple_printer<Out> > walker(pr, what.tag, 0);
+        boost::apply_visitor(walker, what.value);
+        return out;
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <int N>
+    struct argument;
+    template <typename Dummy>
+    struct attribute_context;
+}}
+namespace boost { namespace spirit
+{
+    namespace result_of
+    {
+        template <typename Sequence, int N>
+        struct get_arg
+        {
+            typedef typename
+                fusion::result_of::size<Sequence>::type
+            sequence_size;
+            struct index_is_out_of_bounds; typedef struct
+ index_is_out_of_bounds105
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (index_is_out_of_bounds::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg105
+            ; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<((N < sequence_size::value))>( mpl_assert_arg105::assert_arg() ) ) }
+                                           ;
+            typedef typename
+                fusion::result_of::at_c<Sequence, N>::type
+            type;
+            static type call(Sequence& seq)
+            {
+                return fusion::at_c<N>(seq);
+            }
+        };
+        template <typename Sequence, int N>
+        struct get_arg<Sequence&, N> : get_arg<Sequence, N>
+        {
+        };
+    }
+    template <int N, typename T>
+    typename result_of::get_arg<T, N>::type
+    get_arg(T& val)
+    {
+        return result_of::get_arg<T, N>::call(val);
+    }
+    template <typename>
+    struct attribute_context
+    {
+        typedef mpl::true_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                remove_const<
+                    typename mpl::at_c<typename Env::args_type, 0>::type
+                >::type
+            type;
+        };
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return fusion::at_c<0>(env.args());
+        }
+    };
+    template <int N>
+    struct argument
+    {
+        typedef mpl::true_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                mpl::at_c<typename Env::args_type, 0>::type
+            arg_type;
+            typedef typename result_of::get_arg<arg_type, N>::type type;
+        };
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return get_arg<N>(fusion::at_c<0>(env.args()));
+        }
+    };
+    typedef phoenix::actor<attribute_context<void> > _0_type;
+    _0_type const _0 = _0_type();
+    typedef phoenix::actor<argument<0> > _1_type;
+    typedef phoenix::actor<argument<1> > _2_type;
+    typedef phoenix::actor<argument<2> > _3_type;
+    _1_type const _1 = _1_type();
+    _2_type const _2 = _2_type();
+    _3_type const _3 = _3_type();
+    typedef phoenix::arg_names::_3_type _pass_type;
+    _pass_type const _pass = _pass_type();
+ typedef phoenix::actor<argument<3> > _4_type; phoenix::actor<argument<3> > const _4 = _4_type(); typedef phoenix::actor<argument<4> > _5_type; phoenix::actor<argument<4> > const _5 = _5_type(); typedef phoenix::actor<argument<5> > _6_type; phoenix::actor<argument<5> > const _6 = _6_type(); typedef phoenix::actor<argument<6> > _7_type; phoenix::actor<argument<6> > const _7 = _7_type(); typedef phoenix::actor<argument<7> > _8_type; phoenix::actor<argument<7> > const _8 = _8_type(); typedef phoenix::actor<argument<8> > _9_type; phoenix::actor<argument<8> > const _9 = _9_type(); typedef phoenix::actor<argument<9> > _10_type; phoenix::actor<argument<9> > const _10 = _10_type();
+    namespace labels
+    {
+        using spirit::_0_type; using spirit::_0; using spirit::_1_type; using spirit::_1; using spirit::_2_type; using spirit::_2; using spirit::_3_type; using spirit::_3; using spirit::_4_type; using spirit::_4; using spirit::_5_type; using spirit::_5; using spirit::_6_type; using spirit::_6; using spirit::_7_type; using spirit::_7; using spirit::_8_type; using spirit::_8; using spirit::_9_type; using spirit::_9;
+    }
+}}
+namespace boost { namespace spirit { namespace result_of
+{
+    template <typename Exposed, typename Attribute>
+    struct extract_from;
+    template <typename T, typename Attribute>
+    struct attribute_as;
+    template <typename Exposed, typename Transformed, typename Domain>
+    struct pre_transform;
+    template <typename T>
+    struct optional_value;
+    template <typename Container>
+    struct begin;
+    template <typename Container>
+    struct end;
+    template <typename Iterator>
+    struct deref;
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Expected, typename Enable = void>
+    struct is_substitute;
+    template <typename T, typename Expected, typename Enable = void>
+    struct is_weak_substitute;
+    template <typename T, typename Enable = void>
+    struct is_proxy;
+    template <typename Attribute, typename Enable = void>
+    struct attribute_type;
+    template <typename T>
+    struct sequence_size;
+    template <typename Attribute, typename Enable = void>
+    struct attribute_size;
+    template <typename Attribute>
+    typename attribute_size<Attribute>::type
+    size(Attribute const& attr);
+    template <typename Component, typename Attribute, typename Enable = void>
+    struct pass_attribute;
+    template <typename T, typename Enable = void>
+    struct optional_attribute;
+    template <typename Exposed, typename Transformed, typename Domain
+      , typename Enable = void>
+    struct transform_attribute;
+    template <typename Attribute, typename Iterator, typename Enable = void>
+    struct assign_to_attribute_from_iterators;
+    template <typename Iterator, typename Attribute>
+    void assign_to(Iterator const& first, Iterator const& last, Attribute& attr);
+    template <typename Iterator>
+    void assign_to(Iterator const&, Iterator const&, unused_type);
+    template <typename Attribute, typename T, typename Enable = void>
+    struct assign_to_attribute_from_value;
+    template <typename Attribute, typename T, typename Enable = void>
+    struct assign_to_container_from_value;
+    template <typename T, typename Attribute>
+    void assign_to(T const& val, Attribute& attr);
+    template <typename T>
+    void assign_to(T const&, unused_type);
+    template <typename Attribute, typename Exposed, typename Enable = void>
+    struct extract_from_attribute;
+    template <typename Attribute, typename Exposed, typename Enable = void>
+    struct extract_from_container;
+    template <typename Exposed, typename Attribute, typename Context>
+    typename spirit::result_of::extract_from<Exposed, Attribute>::type
+    extract_from(Attribute const& attr, Context& ctx
+    );
+    template <typename T, typename Attribute, typename Enable = void>
+    struct attribute_as;
+    template <typename T, typename Attribute>
+    typename spirit::result_of::attribute_as<T, Attribute>::type
+    as(Attribute const& attr);
+    template <typename T, typename Attribute>
+    bool valid_as(Attribute const& attr);
+    template <typename T, typename Enable = void>
+    struct variant_which;
+    template <typename T>
+    int which(T const& v);
+    template <typename T, typename Domain = unused_type, typename Enable = void>
+    struct not_is_variant;
+    template <typename T, typename Domain = unused_type, typename Enable = void>
+    struct not_is_optional;
+    template <typename T, typename Enable = void>
+    struct clear_value;
+    template <typename Container, typename Enable = void>
+    struct container_value;
+    template <typename Container, typename Enable = void>
+    struct container_iterator;
+    template <typename T, typename Enable = void>
+    struct is_container;
+    template <typename T, typename Enable = void>
+    struct is_iterator_range;
+    template <typename T, typename Attribute, typename Context = unused_type
+            , typename Iterator = unused_type, typename Enable = void>
+    struct handles_container;
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence, typename Domain, typename Enable = void>
+    struct pass_through_container;
+    template <typename Container, typename T, typename Enable = void>
+    struct push_back_container;
+    template <typename Container, typename Enable = void>
+    struct is_empty_container;
+    template <typename Container, typename Enable = void>
+    struct make_container_attribute;
+    template <typename Container, typename Enable = void>
+    struct begin_container;
+    template <typename Container, typename Enable = void>
+    struct end_container;
+    template <typename Iterator, typename Enable = void>
+    struct deref_iterator;
+    template <typename Iterator, typename Enable = void>
+    struct next_iterator;
+    template <typename Iterator, typename Enable = void>
+    struct compare_iterators;
+    template <typename Out, typename T, typename Enable = void>
+    struct print_attribute_debug;
+    template <typename Out, typename T>
+    void print_attribute(Out&, T const&);
+    template <typename Out>
+    void print_attribute(Out&, unused_type);
+    template <typename Char, typename Enable = void>
+    struct token_printer_debug;
+    template<typename Out, typename T>
+    void print_token(Out&, T const&);
+    template <typename T, typename Attribute, typename Enable = void>
+    struct symbols_lookup;
+    template <typename Attribute, typename T, typename Enable = void>
+    struct symbols_value;
+    template <typename Attribute, typename Domain>
+    struct alternative_attribute_transform;
+    template <typename Attribute, typename Domain>
+    struct sequence_attribute_transform;
+    template <typename Attribute, typename Domain>
+    struct permutation_attribute_transform;
+    template <typename Attribute, typename Domain>
+    struct sequential_or_attribute_transform;
+}}}
+namespace boost {
+  template <class T>
+  struct type {};
+}
+namespace boost {
+namespace detail { struct none_helper{}; }
+typedef int detail::none_helper::*none_t ;
+}
+namespace boost {
+none_t const none = (static_cast<none_t>(0)) ;
+}
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;
+    swap(left,right);
+  }
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+namespace boost {
+template<class OptionalPointee>
+inline
+bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
+{
+  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
+}
+template<class OptionalPointee>
+struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+{
+  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
+    { return equal_pointees(x,y) ; }
+} ;
+template<class OptionalPointee>
+inline
+bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
+{
+  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
+}
+template<class OptionalPointee>
+struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+{
+  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
+    { return less_pointees(x,y) ; }
+} ;
+}
+namespace boost {
+class in_place_factory_base {} ;
+class in_place_factory0
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory0
+      ( )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+};
+inline in_place_factory0 in_place()
+{
+  return in_place_factory0();
+}
+template< class A0 >
+class in_place_factory1
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory1
+      ( A0 const& a0 )
+    : m_a0 ( a0 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0;
+};
+template< class A0 >
+inline in_place_factory1< A0 >
+in_place( A0 const& a0 )
+{
+  return in_place_factory1< A0 >
+      ( a0 );
+}
+template< class A0 , class A1 >
+class in_place_factory2
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory2
+      ( A0 const& a0 , A1 const& a1 )
+    : m_a0 ( a0 ) , m_a1 ( a1 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1;
+};
+template< class A0 , class A1 >
+inline in_place_factory2< A0 , A1 >
+in_place( A0 const& a0 , A1 const& a1 )
+{
+  return in_place_factory2< A0 , A1 >
+      ( a0 , a1 );
+}
+template< class A0 , class A1 , class A2 >
+class in_place_factory3
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory3
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2;
+};
+template< class A0 , class A1 , class A2 >
+inline in_place_factory3< A0 , A1 , A2 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 )
+{
+  return in_place_factory3< A0 , A1 , A2 >
+      ( a0 , a1 , a2 );
+}
+template< class A0 , class A1 , class A2 , class A3 >
+class in_place_factory4
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory4
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3;
+};
+template< class A0 , class A1 , class A2 , class A3 >
+inline in_place_factory4< A0 , A1 , A2 , A3 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 )
+{
+  return in_place_factory4< A0 , A1 , A2 , A3 >
+      ( a0 , a1 , a2 , a3 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 >
+class in_place_factory5
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory5
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 >
+inline in_place_factory5< A0 , A1 , A2 , A3 , A4 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 )
+{
+  return in_place_factory5< A0 , A1 , A2 , A3 , A4 >
+      ( a0 , a1 , a2 , a3 , a4 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
+class in_place_factory6
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory6
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
+inline in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 )
+{
+  return in_place_factory6< A0 , A1 , A2 , A3 , A4 , A5 >
+      ( a0 , a1 , a2 , a3 , a4 , a5 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
+class in_place_factory7
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory7
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
+inline in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 )
+{
+  return in_place_factory7< A0 , A1 , A2 , A3 , A4 , A5 , A6 >
+      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
+class in_place_factory8
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory8
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
+inline in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 )
+{
+  return in_place_factory8< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 >
+      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
+class in_place_factory9
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory9
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
+inline in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 )
+{
+  return in_place_factory9< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 >
+      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 );
+}
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
+class in_place_factory10
+  :
+  public in_place_factory_base
+{
+public:
+  explicit in_place_factory10
+      ( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )
+    : m_a0 ( a0 ) , m_a1 ( a1 ) , m_a2 ( a2 ) , m_a3 ( a3 ) , m_a4 ( a4 ) , m_a5 ( a5 ) , m_a6 ( a6 ) , m_a7 ( a7 ) , m_a8 ( a8 ) , m_a9 ( a9 )
+  {}
+  template<class T>
+  void* apply(void* address
+      ) const
+  {
+    return new(address) T( m_a0 , m_a1 , m_a2 , m_a3 , m_a4 , m_a5 , m_a6 , m_a7 , m_a8 , m_a9 );
+  }
+  template<class T>
+  void* apply(void* address, std::size_t n
+      ) const
+  {
+    for(char* next = address = this->template apply<T>(address);
+        !! --n;)
+      this->template apply<T>(next = next+sizeof(T));
+    return address;
+  }
+  A0 const& m_a0; A1 const& m_a1; A2 const& m_a2; A3 const& m_a3; A4 const& m_a4; A5 const& m_a5; A6 const& m_a6; A7 const& m_a7; A8 const& m_a8; A9 const& m_a9;
+};
+template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
+inline in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
+in_place( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 )
+{
+  return in_place_factory10< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 >
+      ( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 );
+}
+}
+namespace boost {
+template<class T> class optional ;
+template<class T> void swap ( optional<T>& , optional<T>& ) ;
+template<class T> struct optional_swap_should_use_default_constructor ;
+}
+namespace boost_optional_detail
+{
+  template <class T, class Factory>
+  inline void construct(Factory const& factory, void* address)
+  {
+    factory.template apply<T>(address);
+  }
+}
+namespace boost {
+class in_place_factory_base ;
+class typed_in_place_factory_base ;
+template<class T> void swap ( optional<T>& x, optional<T>& y );
+namespace optional_detail {
+template <class T>
+class aligned_storage
+{
+    union
+    __attribute__((may_alias))
+    dummy_u
+    {
+        char data[ sizeof(T) ];
+        typename type_with_alignment<
+          ::boost::alignment_of<T>::value >::type aligner_;
+    } dummy_ ;
+  public:
+    void const* address() const { return &dummy_; }
+    void * address() { return &dummy_; }
+} ;
+template<class T>
+struct types_when_isnt_ref
+{
+  typedef T const& reference_const_type ;
+  typedef T & reference_type ;
+  typedef T const* pointer_const_type ;
+  typedef T * pointer_type ;
+  typedef T const& argument_type ;
+} ;
+template<class T>
+struct types_when_is_ref
+{
+  typedef typename remove_reference<T>::type raw_type ;
+  typedef raw_type& reference_const_type ;
+  typedef raw_type& reference_type ;
+  typedef raw_type* pointer_const_type ;
+  typedef raw_type* pointer_type ;
+  typedef raw_type& argument_type ;
+} ;
+struct optional_tag {} ;
+template<class T>
+class optional_base : public optional_tag
+{
+  private :
+    typedef
+    typename
+    ::boost::detail::make_reference_content<T>::type internal_type ;
+    typedef aligned_storage<internal_type> storage_type ;
+    typedef types_when_isnt_ref<T> types_when_not_ref ;
+    typedef types_when_is_ref<T> types_when_ref ;
+    typedef optional_base<T> this_type ;
+  protected :
+    typedef T value_type ;
+    typedef mpl::true_ is_reference_tag ;
+    typedef mpl::false_ is_not_reference_tag ;
+    typedef typename is_reference<T>::type is_reference_predicate ;
+  public:
+    typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
+  protected:
+    typedef bool (this_type::*unspecified_bool_type)() const;
+    typedef typename types::reference_type reference_type ;
+    typedef typename types::reference_const_type reference_const_type ;
+    typedef typename types::pointer_type pointer_type ;
+    typedef typename types::pointer_const_type pointer_const_type ;
+    typedef typename types::argument_type argument_type ;
+    optional_base()
+      :
+      m_initialized(false) {}
+    optional_base ( none_t )
+      :
+      m_initialized(false) {}
+    optional_base ( argument_type val )
+      :
+      m_initialized(false)
+    {
+      construct(val);
+    }
+    optional_base ( bool cond, argument_type val )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(val);
+    }
+    optional_base ( optional_base const& rhs )
+      :
+      m_initialized(false)
+    {
+      if ( rhs.is_initialized() )
+        construct(rhs.get_impl());
+    }
+    template<class Expr>
+    explicit optional_base ( Expr const& expr, Expr const* tag )
+      :
+      m_initialized(false)
+    {
+      construct(expr,tag);
+    }
+    ~optional_base() { destroy() ; }
+    void assign ( optional_base const& rhs )
+    {
+      if (is_initialized())
+      {
+        if ( rhs.is_initialized() )
+             assign_value(rhs.get_impl(), is_reference_predicate() );
+        else destroy();
+      }
+      else
+      {
+        if ( rhs.is_initialized() )
+          construct(rhs.get_impl());
+      }
+    }
+    template<class U>
+    void assign ( optional<U> const& rhs )
+    {
+      if (is_initialized())
+      {
+        if ( rhs.is_initialized() )
+             assign_value(static_cast<value_type>(rhs.get()), is_reference_predicate() );
+        else destroy();
+      }
+      else
+      {
+        if ( rhs.is_initialized() )
+          construct(static_cast<value_type>(rhs.get()));
+      }
+    }
+    void assign ( argument_type val )
+    {
+      if (is_initialized())
+           assign_value(val, is_reference_predicate() );
+      else construct(val);
+    }
+    void assign ( none_t ) { destroy(); }
+    template<class Expr>
+    void assign_expr ( Expr const& expr, Expr const* tag )
+      {
+        if (is_initialized())
+             assign_expr_to_initialized(expr,tag);
+        else construct(expr,tag);
+      }
+  public :
+    void reset() { destroy(); }
+    void reset ( argument_type val ) { assign(val); }
+    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
+    pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }
+    bool is_initialized() const { return m_initialized ; }
+  protected :
+    void construct ( argument_type val )
+     {
+       new (m_storage.address()) internal_type(val) ;
+       m_initialized = true ;
+     }
+    template<class Expr>
+    void construct ( Expr const& factory, in_place_factory_base const* )
+     {
+       typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::mpl::not_<is_reference_predicate>::value) == 0 ? false : true) >)> boost_static_assert_typedef_355 ;
+       boost_optional_detail::construct<value_type>(factory, m_storage.address());
+       m_initialized = true ;
+     }
+    template<class Expr>
+    void construct ( Expr const& factory, typed_in_place_factory_base const* )
+     {
+       typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::mpl::not_<is_reference_predicate>::value) == 0 ? false : true) >)> boost_static_assert_typedef_364 ;
+       factory.apply(m_storage.address()) ;
+       m_initialized = true ;
+     }
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+    template<class Expr>
+    void construct ( Expr const& expr, void const* )
+     {
+       new (m_storage.address()) internal_type(expr) ;
+       m_initialized = true ;
+     }
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& expr, void const* )
+     {
+       assign_value(expr, is_reference_predicate());
+     }
+    void assign_value ( argument_type val, is_not_reference_tag ) { get_impl() = val; }
+    void assign_value ( argument_type val, is_reference_tag ) { construct(val); }
+    void destroy()
+    {
+      if ( m_initialized )
+        destroy_impl(is_reference_predicate()) ;
+    }
+    unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; }
+    reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; }
+    reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; }
+    pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; }
+    pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; }
+  private :
+    internal_type const* get_object() const
+    {
+        union { void const* ap_pvoid; internal_type const* as_ptype; } caster = { m_storage.address() };
+        return caster.as_ptype;
+    }
+    internal_type * get_object()
+    {
+        union { void* ap_pvoid; internal_type* as_ptype; } caster = { m_storage.address() };
+        return caster.as_ptype;
+    }
+    reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; }
+    reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; }
+    reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; }
+    reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; }
+    void destroy_impl ( is_not_reference_tag ) { get_ptr_impl()->T::~T() ; m_initialized = false ; }
+    void destroy_impl ( is_reference_tag ) { m_initialized = false ; }
+    pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; }
+    pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; }
+    pointer_const_type cast_ptr( internal_type const* p, is_reference_tag ) const { return &p->get() ; }
+    pointer_type cast_ptr( internal_type * p, is_reference_tag ) { return &p->get() ; }
+    bool m_initialized ;
+    storage_type m_storage ;
+} ;
+}
+template<class T>
+class optional : public optional_detail::optional_base<T>
+{
+    typedef optional_detail::optional_base<T> base ;
+    typedef typename base::unspecified_bool_type unspecified_bool_type ;
+  public :
+    typedef optional<T> this_type ;
+    typedef typename base::value_type value_type ;
+    typedef typename base::reference_type reference_type ;
+    typedef typename base::reference_const_type reference_const_type ;
+    typedef typename base::pointer_type pointer_type ;
+    typedef typename base::pointer_const_type pointer_const_type ;
+    typedef typename base::argument_type argument_type ;
+    optional() : base() {}
+    optional( none_t none_ ) : base(none_) {}
+    optional ( argument_type val ) : base(val) {}
+    optional ( bool cond, argument_type val ) : base(cond,val) {}
+    template<class U>
+    explicit optional ( optional<U> const& rhs )
+      :
+      base()
+    {
+      if ( rhs.is_initialized() )
+        this->construct(rhs.get());
+    }
+    template<class Expr>
+    explicit optional ( Expr const& expr ) : base(expr,boost::addressof(expr)) {}
+    optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
+    ~optional() {}
+    template<class Expr>
+    optional& operator= ( Expr const& expr )
+      {
+        this->assign_expr(expr,boost::addressof(expr));
+        return *this ;
+      }
+    template<class U>
+    optional& operator= ( optional<U> const& rhs )
+      {
+        this->assign(rhs);
+        return *this ;
+      }
+    optional& operator= ( optional const& rhs )
+      {
+        this->assign( static_cast<base const&>(rhs) ) ;
+        return *this ;
+      }
+    optional& operator= ( argument_type val )
+      {
+        this->assign( val ) ;
+        return *this ;
+      }
+    optional& operator= ( none_t none_ )
+      {
+        this->assign( none_ ) ;
+        return *this ;
+      }
+    void swap( optional & arg )
+      {
+        using boost::swap;
+        swap(*this, arg);
+      }
+    reference_const_type get() const { (static_cast<void> (0)) ; return this->get_impl(); }
+    reference_type get() { (static_cast<void> (0)) ; return this->get_impl(); }
+    reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }
+    reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; }
+    pointer_const_type operator->() const { (static_cast<void> (0)) ; return this->get_ptr_impl() ; }
+    pointer_type operator->() { (static_cast<void> (0)) ; return this->get_ptr_impl() ; }
+    reference_const_type operator *() const { return this->get() ; }
+    reference_type operator *() { return this->get() ; }
+    operator unspecified_bool_type() const { return this->safe_bool() ; }
+    bool operator!() const { return !this->is_initialized() ; }
+} ;
+template<class T>
+inline
+optional<T> make_optional ( T const& v )
+{
+  return optional<T>(v);
+}
+template<class T>
+inline
+optional<T> make_optional ( bool cond, T const& v )
+{
+  return optional<T>(cond,v);
+}
+template<class T>
+inline
+typename optional<T>::reference_const_type
+get ( optional<T> const& opt )
+{
+  return opt.get() ;
+}
+template<class T>
+inline
+typename optional<T>::reference_type
+get ( optional<T>& opt )
+{
+  return opt.get() ;
+}
+template<class T>
+inline
+typename optional<T>::pointer_const_type
+get ( optional<T> const* opt )
+{
+  return opt->get_ptr() ;
+}
+template<class T>
+inline
+typename optional<T>::pointer_type
+get ( optional<T>* opt )
+{
+  return opt->get_ptr() ;
+}
+template<class T>
+inline
+typename optional<T>::reference_const_type
+get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type v )
+{
+  return opt.get_value_or(v) ;
+}
+template<class T>
+inline
+typename optional<T>::reference_type
+get_optional_value_or ( optional<T>& opt, typename optional<T>::reference_type v )
+{
+  return opt.get_value_or(v) ;
+}
+template<class T>
+inline
+typename optional<T>::pointer_const_type
+get_pointer ( optional<T> const& opt )
+{
+  return opt.get_ptr() ;
+}
+template<class T>
+inline
+typename optional<T>::pointer_type
+get_pointer ( optional<T>& opt )
+{
+  return opt.get_ptr() ;
+}
+template<class T>
+inline
+bool operator == ( optional<T> const& x, optional<T> const& y )
+{ return equal_pointees(x,y); }
+template<class T>
+inline
+bool operator < ( optional<T> const& x, optional<T> const& y )
+{ return less_pointees(x,y); }
+template<class T>
+inline
+bool operator != ( optional<T> const& x, optional<T> const& y )
+{ return !( x == y ) ; }
+template<class T>
+inline
+bool operator > ( optional<T> const& x, optional<T> const& y )
+{ return y < x ; }
+template<class T>
+inline
+bool operator <= ( optional<T> const& x, optional<T> const& y )
+{ return !( y < x ) ; }
+template<class T>
+inline
+bool operator >= ( optional<T> const& x, optional<T> const& y )
+{ return !( x < y ) ; }
+template<class T>
+inline
+bool operator == ( optional<T> const& x, T const& y )
+{ return equal_pointees(x, optional<T>(y)); }
+template<class T>
+inline
+bool operator < ( optional<T> const& x, T const& y )
+{ return less_pointees(x, optional<T>(y)); }
+template<class T>
+inline
+bool operator != ( optional<T> const& x, T const& y )
+{ return !( x == y ) ; }
+template<class T>
+inline
+bool operator > ( optional<T> const& x, T const& y )
+{ return y < x ; }
+template<class T>
+inline
+bool operator <= ( optional<T> const& x, T const& y )
+{ return !( y < x ) ; }
+template<class T>
+inline
+bool operator >= ( optional<T> const& x, T const& y )
+{ return !( x < y ) ; }
+template<class T>
+inline
+bool operator == ( T const& x, optional<T> const& y )
+{ return equal_pointees( optional<T>(x), y ); }
+template<class T>
+inline
+bool operator < ( T const& x, optional<T> const& y )
+{ return less_pointees( optional<T>(x), y ); }
+template<class T>
+inline
+bool operator != ( T const& x, optional<T> const& y )
+{ return !( x == y ) ; }
+template<class T>
+inline
+bool operator > ( T const& x, optional<T> const& y )
+{ return y < x ; }
+template<class T>
+inline
+bool operator <= ( T const& x, optional<T> const& y )
+{ return !( y < x ) ; }
+template<class T>
+inline
+bool operator >= ( T const& x, optional<T> const& y )
+{ return !( x < y ) ; }
+template<class T>
+inline
+bool operator == ( optional<T> const& x, none_t )
+{ return equal_pointees(x, optional<T>() ); }
+template<class T>
+inline
+bool operator < ( optional<T> const& x, none_t )
+{ return less_pointees(x,optional<T>() ); }
+template<class T>
+inline
+bool operator != ( optional<T> const& x, none_t y )
+{ return !( x == y ) ; }
+template<class T>
+inline
+bool operator > ( optional<T> const& x, none_t y )
+{ return y < x ; }
+template<class T>
+inline
+bool operator <= ( optional<T> const& x, none_t y )
+{ return !( y < x ) ; }
+template<class T>
+inline
+bool operator >= ( optional<T> const& x, none_t y )
+{ return !( x < y ) ; }
+template<class T>
+inline
+bool operator == ( none_t x, optional<T> const& y )
+{ return equal_pointees(optional<T>() ,y); }
+template<class T>
+inline
+bool operator < ( none_t x, optional<T> const& y )
+{ return less_pointees(optional<T>() ,y); }
+template<class T>
+inline
+bool operator != ( none_t x, optional<T> const& y )
+{ return !( x == y ) ; }
+template<class T>
+inline
+bool operator > ( none_t x, optional<T> const& y )
+{ return y < x ; }
+template<class T>
+inline
+bool operator <= ( none_t x, optional<T> const& y )
+{ return !( y < x ) ; }
+template<class T>
+inline
+bool operator >= ( none_t x, optional<T> const& y )
+{ return !( x < y ) ; }
+namespace optional_detail {
+template<bool use_default_constructor> struct swap_selector;
+template<>
+struct swap_selector<true>
+{
+    template<class T>
+    static void optional_swap ( optional<T>& x, optional<T>& y )
+    {
+        const bool hasX = !!x;
+        const bool hasY = !!y;
+        if ( !hasX && !hasY )
+            return;
+        if( !hasX )
+            x = boost::in_place();
+        else if ( !hasY )
+            y = boost::in_place();
+        boost::swap(x.get(),y.get());
+        if( !hasX )
+            y = boost::none ;
+        else if( !hasY )
+            x = boost::none ;
+    }
+};
+template<>
+struct swap_selector<false>
+{
+    template<class T>
+    static void optional_swap ( optional<T>& x, optional<T>& y )
+    {
+        const bool hasX = !!x;
+        const bool hasY = !!y;
+        if ( !hasX && hasY )
+        {
+            x = y.get();
+            y = boost::none ;
+        }
+        else if ( hasX && !hasY )
+        {
+            y = x.get();
+            x = boost::none ;
+        }
+        else if ( hasX && hasY )
+        {
+            boost::swap(x.get(),y.get());
+        }
+    }
+};
+}
+template<class T>
+struct optional_swap_should_use_default_constructor : has_nothrow_default_constructor<T> {} ;
+template<class T> inline void swap ( optional<T>& x, optional<T>& y )
+{
+    optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
+}
+}
+namespace boost {
+class bad_get
+    : public std::exception
+{
+public:
+    virtual const char * what() const throw()
+    {
+        return "boost::bad_get: "
+               "failed value get using boost::get";
+    }
+};
+namespace detail { namespace variant {
+template <typename T>
+struct get_visitor
+{
+private:
+    typedef typename add_pointer<T>::type pointer;
+    typedef typename add_reference<T>::type reference;
+public:
+    typedef pointer result_type;
+public:
+    pointer operator()(reference operand) const
+    {
+        return boost::addressof(operand);
+    }
+    template <typename U>
+    pointer operator()(const U&) const
+    {
+        return static_cast<pointer>(0);
+    }
+};
+}}
+template <typename U, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+inline
+    typename add_pointer<U>::type
+get(
+      boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >* operand
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+    detail::variant::get_visitor<U> v;
+    return operand->apply_visitor(v);
+}
+template <typename U, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+inline
+    typename add_pointer<const U>::type
+get(
+      const boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >* operand
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+    detail::variant::get_visitor<const U> v;
+    return operand->apply_visitor(v);
+}
+template <typename U, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+inline
+    typename add_reference<U>::type
+get(
+      boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >& operand
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = get<U>(&operand);
+    if (!result)
+        throw bad_get();
+    return *result;
+}
+template <typename U, typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+inline
+    typename add_reference<const U>::type
+get(
+      const boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 >& operand
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    U_ptr result = get<const U>(&operand);
+    if (!result)
+        throw bad_get();
+    return *result;
+}
+}
+namespace boost {
+struct bad_visit
+    : std::exception
+{
+public:
+    virtual const char * what() const throw()
+    {
+        return "boost::bad_visit: "
+               "failed visitation using boost::apply_visitor";
+    }
+};
+}
+namespace boost {
+template <typename T, typename R>
+class visitor_ptr_t
+    : public static_visitor<R>
+{
+private:
+    typedef R (*visitor_t)(T);
+    visitor_t visitor_;
+public:
+    typedef R result_type;
+private:
+    typedef typename mpl::eval_if<
+          is_reference<T>
+        , mpl::identity<T>
+        , add_reference<const T>
+        >::type argument_fwd_type;
+public:
+    explicit visitor_ptr_t(visitor_t visitor)
+      : visitor_(visitor)
+    {
+    }
+public:
+    template <typename U>
+    result_type operator()(const U&) const
+    {
+        throw bad_visit();
+    }
+public:
+    result_type operator()(argument_fwd_type operand) const
+    {
+        return visitor_(operand);
+    }
+};
+template <typename R, typename T>
+inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T))
+{
+    return visitor_ptr_t<T,R>(visitor);
+}
+}
+namespace boost
+{
+    template< class T >
+    struct range_difference : iterator_difference< typename range_iterator<T>::type >
+    { };
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        template<class SinglePassRange>
+        inline typename range_difference<SinglePassRange>::type
+        range_calculate_size(const SinglePassRange& rng)
+        {
+            (static_cast<void> (0))
+                                                            ;
+            return boost::end(rng) - boost::begin(rng);
+        }
+    }
+    template<class SinglePassRange>
+    inline typename range_difference<SinglePassRange>::type
+    size(const SinglePassRange& rng)
+    {
+        using namespace range_detail;
+        return range_calculate_size(rng);
+    }
+}
+namespace boost
+{
+    template< class T >
+    inline typename range_difference<T>::type
+    distance( const T& r )
+    {
+        return std::distance( boost::begin( r ), boost::end( r ) );
+    }
+}
+namespace boost
+{
+    template< class T >
+    inline bool empty( const T& r )
+    {
+        return boost::begin( r ) == boost::end( r );
+    }
+}
+namespace boost
+{
+  namespace concepts {}
+}
+namespace boost { namespace concepts {
+namespace detail
+{
+  typedef char yes;
+  typedef char (&no)[2];
+  template <class Model, void (Model::*)()>
+  struct wrap_constraints {};
+  template <class Model>
+  inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
+  inline no has_constraints_(...);
+}
+template <class Model>
+struct not_satisfied
+{
+    static const bool value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes)
+                                                                                      ;
+    typedef mpl::bool_<value> type;
+};
+}}
+namespace boost { namespace concepts {
+template <class ModelFn>
+struct requirement_;
+namespace detail
+{
+  template <void(*)()> struct instantiate {};
+}
+template <class Model>
+struct requirement
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+struct failed {};
+template <class Model>
+struct requirement<failed ************ Model::************>
+{
+    static void failed() { ((Model*)0)->~Model(); }
+};
+template <class Model>
+struct constraint
+{
+    static void failed() { ((Model*)0)->constraints(); }
+};
+template <class Model>
+struct requirement_<void(*)(Model)>
+  : mpl::if_<
+        concepts::not_satisfied<Model>
+      , constraint<Model>
+      , requirement<failed ************ Model::************>
+    >::type
+{};
+}}
+namespace boost { namespace concepts {
+template <class Model>
+struct usage_requirements
+{
+    ~usage_requirements() { ((Model*)0)->~Model(); }
+};
+}}
+namespace boost
+{
+  template <class Model>
+  inline void function_requires(Model* = 0)
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Model)>::failed> boost_concept_check45;
+  }
+  template <class T> inline void ignore_unused_variable_warning(T const&) {}
+  template < typename T > struct Integer; template < typename T > struct IntegerConcept : Integer< T > { }; template < typename T > struct Integer
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Integer>)>::failed> boost_concept_check67; ~Integer()
+        {
+            x.error_type_must_be_an_integer_type();
+        }
+   private:
+      T x;
+  };
+  template <> struct Integer<char> {};
+  template <> struct Integer<signed char> {};
+  template <> struct Integer<unsigned char> {};
+  template <> struct Integer<short> {};
+  template <> struct Integer<unsigned short> {};
+  template <> struct Integer<int> {};
+  template <> struct Integer<unsigned int> {};
+  template <> struct Integer<long> {};
+  template <> struct Integer<unsigned long> {};
+  template <> struct Integer< ::boost::long_long_type> {};
+  template <> struct Integer< ::boost::ulong_long_type> {};
+  template < typename T > struct SignedInteger; template < typename T > struct SignedIntegerConcept : SignedInteger< T > { }; template < typename T > struct SignedInteger {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SignedInteger>)>::failed> boost_concept_check93; ~SignedInteger() {
+      x.error_type_must_be_a_signed_integer_type();
+    }
+   private:
+    T x;
+  };
+  template <> struct SignedInteger<signed char> { };
+  template <> struct SignedInteger<short> {};
+  template <> struct SignedInteger<int> {};
+  template <> struct SignedInteger<long> {};
+  template <> struct SignedInteger< ::boost::long_long_type> {};
+  template < typename T > struct UnsignedInteger; template < typename T > struct UnsignedIntegerConcept : UnsignedInteger< T > { }; template < typename T > struct UnsignedInteger {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnsignedInteger>)>::failed> boost_concept_check110; ~UnsignedInteger() {
+      x.error_type_must_be_an_unsigned_integer_type();
+    }
+   private:
+    T x;
+  };
+  template <> struct UnsignedInteger<unsigned char> {};
+  template <> struct UnsignedInteger<unsigned short> {};
+  template <> struct UnsignedInteger<unsigned int> {};
+  template <> struct UnsignedInteger<unsigned long> {};
+  template <> struct UnsignedInteger< ::boost::ulong_long_type> {};
+  template < typename TT > struct DefaultConstructible; template < typename TT > struct DefaultConstructibleConcept : DefaultConstructible< TT > { }; template < typename TT > struct DefaultConstructible
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DefaultConstructible>)>::failed> boost_concept_check132; ~DefaultConstructible() {
+      TT a;
+      ignore_unused_variable_warning(a);
+    }
+  };
+  template < typename TT > struct Assignable; template < typename TT > struct AssignableConcept : Assignable< TT > { }; template < typename TT > struct Assignable
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Assignable>)>::failed> boost_concept_check140; ~Assignable() {
+      a = b;
+      const_constraints(b);
+    }
+   private:
+    void const_constraints(const TT& x) {
+      a = x;
+    }
+   private:
+    TT a;
+    TT b;
+  };
+  template < typename TT > struct CopyConstructible; template < typename TT > struct CopyConstructibleConcept : CopyConstructible< TT > { }; template < typename TT > struct CopyConstructible
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<CopyConstructible>)>::failed> boost_concept_check162; ~CopyConstructible() {
+      TT a(b);
+      TT* ptr = &a;
+      const_constraints(a);
+      ignore_unused_variable_warning(ptr);
+    }
+   private:
+    void const_constraints(const TT& a) {
+      TT c(a);
+      const TT* ptr = &a;
+      ignore_unused_variable_warning(c);
+      ignore_unused_variable_warning(ptr);
+    }
+    TT b;
+  };
+  template < typename TT > struct SGIAssignable; template < typename TT > struct SGIAssignableConcept : SGIAssignable< TT > { }; template < typename TT > struct SGIAssignable
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SGIAssignable>)>::failed> boost_concept_check186; ~SGIAssignable() {
+      TT c(a);
+      a = b;
+      const_constraints(b);
+      ignore_unused_variable_warning(c);
+    }
+   private:
+    void const_constraints(const TT& x) {
+      TT c(x);
+      a = x;
+      ignore_unused_variable_warning(c);
+    }
+    TT a;
+    TT b;
+  };
+  template < typename X , typename Y > struct Convertible; template < typename X , typename Y > struct ConvertibleConcept : Convertible< X, Y > { }; template < typename X , typename Y > struct Convertible
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Convertible>)>::failed> boost_concept_check211; ~Convertible() {
+      Y y = x;
+      ignore_unused_variable_warning(y);
+    }
+   private:
+    X x;
+  };
+  template <class TT>
+  void require_boolean_expr(const TT& t) {
+    bool x = t;
+    ignore_unused_variable_warning(x);
+  }
+  template < typename TT > struct EqualityComparable; template < typename TT > struct EqualityComparableConcept : EqualityComparable< TT > { }; template < typename TT > struct EqualityComparable
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualityComparable>)>::failed> boost_concept_check236; ~EqualityComparable() {
+      require_boolean_expr(a == b);
+      require_boolean_expr(a != b);
+    }
+   private:
+    TT a, b;
+  };
+  template < typename TT > struct LessThanComparable; template < typename TT > struct LessThanComparableConcept : LessThanComparable< TT > { }; template < typename TT > struct LessThanComparable
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanComparable>)>::failed> boost_concept_check246; ~LessThanComparable() {
+      require_boolean_expr(a < b);
+    }
+   private:
+    TT a, b;
+  };
+  template < typename TT > struct Comparable; template < typename TT > struct ComparableConcept : Comparable< TT > { }; template < typename TT > struct Comparable
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Comparable>)>::failed> boost_concept_check256; ~Comparable() {
+      require_boolean_expr(a < b);
+      require_boolean_expr(a > b);
+      require_boolean_expr(a <= b);
+      require_boolean_expr(a >= b);
+    }
+   private:
+    TT a, b;
+  };
+  template < typename First , typename Second > struct EqualOp; template < typename First , typename Second > struct EqualOpConcept : EqualOp< First, Second > { }; template < typename First , typename Second > struct EqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualOp>)>::failed> boost_concept_check286; ~EqualOp() { (void)constraints_(); } private: bool constraints_() { return a == b; } First a; Second b; };
+  template < typename First , typename Second > struct NotEqualOp; template < typename First , typename Second > struct NotEqualOpConcept : NotEqualOp< First, Second > { }; template < typename First , typename Second > struct NotEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<NotEqualOp>)>::failed> boost_concept_check287; ~NotEqualOp() { (void)constraints_(); } private: bool constraints_() { return a != b; } First a; Second b; };
+  template < typename First , typename Second > struct LessThanOp; template < typename First , typename Second > struct LessThanOpConcept : LessThanOp< First, Second > { }; template < typename First , typename Second > struct LessThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanOp>)>::failed> boost_concept_check288; ~LessThanOp() { (void)constraints_(); } private: bool constraints_() { return a < b; } First a; Second b; };
+  template < typename First , typename Second > struct LessEqualOp; template < typename First , typename Second > struct LessEqualOpConcept : LessEqualOp< First, Second > { }; template < typename First , typename Second > struct LessEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessEqualOp>)>::failed> boost_concept_check289; ~LessEqualOp() { (void)constraints_(); } private: bool constraints_() { return a <= b; } First a; Second b; };
+  template < typename First , typename Second > struct GreaterThanOp; template < typename First , typename Second > struct GreaterThanOpConcept : GreaterThanOp< First, Second > { }; template < typename First , typename Second > struct GreaterThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterThanOp>)>::failed> boost_concept_check290; ~GreaterThanOp() { (void)constraints_(); } private: bool constraints_() { return a > b; } First a; Second b; };
+  template < typename First , typename Second > struct GreaterEqualOp; template < typename First , typename Second > struct GreaterEqualOpConcept : GreaterEqualOp< First, Second > { }; template < typename First , typename Second > struct GreaterEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterEqualOp>)>::failed> boost_concept_check291; ~GreaterEqualOp() { (void)constraints_(); } private: bool constraints_() { return a >= b; } First a; Second b; };
+  template < typename Ret , typename First , typename Second > struct PlusOp; template < typename Ret , typename First , typename Second > struct PlusOpConcept : PlusOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct PlusOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PlusOp>)>::failed> boost_concept_check293; ~PlusOp() { (void)constraints_(); } private: Ret constraints_() { return a + b; } First a; Second b; };
+  template < typename Ret , typename First , typename Second > struct TimesOp; template < typename Ret , typename First , typename Second > struct TimesOpConcept : TimesOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct TimesOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<TimesOp>)>::failed> boost_concept_check294; ~TimesOp() { (void)constraints_(); } private: Ret constraints_() { return a * b; } First a; Second b; };
+  template < typename Ret , typename First , typename Second > struct DivideOp; template < typename Ret , typename First , typename Second > struct DivideOpConcept : DivideOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct DivideOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DivideOp>)>::failed> boost_concept_check295; ~DivideOp() { (void)constraints_(); } private: Ret constraints_() { return a / b; } First a; Second b; };
+  template < typename Ret , typename First , typename Second > struct SubtractOp; template < typename Ret , typename First , typename Second > struct SubtractOpConcept : SubtractOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct SubtractOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SubtractOp>)>::failed> boost_concept_check296; ~SubtractOp() { (void)constraints_(); } private: Ret constraints_() { return a - b; } First a; Second b; };
+  template < typename Ret , typename First , typename Second > struct ModOp; template < typename Ret , typename First , typename Second > struct ModOpConcept : ModOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct ModOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ModOp>)>::failed> boost_concept_check297; ~ModOp() { (void)constraints_(); } private: Ret constraints_() { return a % b; } First a; Second b; };
+  template < typename Func , typename Return > struct Generator; template < typename Func , typename Return > struct GeneratorConcept : Generator< Func, Return > { }; template < typename Func , typename Return > struct Generator
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Generator>)>::failed> boost_concept_check304; ~Generator() { test(is_void<Return>()); }
+   private:
+      void test(boost::mpl::false_)
+      {
+          const Return& r = f();
+          ignore_unused_variable_warning(r);
+      }
+      void test(boost::mpl::true_)
+      {
+          f();
+      }
+      Func f;
+  };
+  template < typename Func , typename Return , typename Arg > struct UnaryFunction; template < typename Func , typename Return , typename Arg > struct UnaryFunctionConcept : UnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct UnaryFunction
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryFunction>)>::failed> boost_concept_check324; ~UnaryFunction() { test(is_void<Return>()); }
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(arg);
+          Return r = f(arg);
+          ignore_unused_variable_warning(r);
+      }
+      void test(boost::mpl::true_)
+      {
+          f(arg);
+      }
+      UnaryFunction();
+      Func f;
+      Arg arg;
+  };
+  template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunctionConcept : BinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryFunction>)>::failed> boost_concept_check354; ~BinaryFunction() { test(is_void<Return>()); }
+   private:
+      void test(boost::mpl::false_)
+      {
+          f(first,second);
+          Return r = f(first, second);
+          (void)r;
+      }
+      void test(boost::mpl::true_)
+      {
+          f(first,second);
+      }
+      BinaryFunction();
+      Func f;
+      First first;
+      Second second;
+  };
+  template < typename Func , typename Arg > struct UnaryPredicate; template < typename Func , typename Arg > struct UnaryPredicateConcept : UnaryPredicate< Func, Arg > { }; template < typename Func , typename Arg > struct UnaryPredicate
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryPredicate>)>::failed> boost_concept_check384; ~UnaryPredicate() {
+      require_boolean_expr(f(arg));
+    }
+   private:
+      UnaryPredicate();
+    Func f;
+    Arg arg;
+  };
+  template < typename Func , typename First , typename Second > struct BinaryPredicate; template < typename Func , typename First , typename Second > struct BinaryPredicateConcept : BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct BinaryPredicate
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryPredicate>)>::failed> boost_concept_check403; ~BinaryPredicate() {
+      require_boolean_expr(f(a, b));
+    }
+   private:
+      BinaryPredicate();
+    Func f;
+    First a;
+    Second b;
+  };
+  template < typename Func , typename First , typename Second > struct Const_BinaryPredicate; template < typename Func , typename First , typename Second > struct Const_BinaryPredicateConcept : Const_BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct Const_BinaryPredicate
+    : BinaryPredicate<Func, First, Second>
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Const_BinaryPredicate>)>::failed> boost_concept_check424; ~Const_BinaryPredicate() {
+      const_constraints(f);
+    }
+   private:
+    void const_constraints(const Func& fun) {
+      require_boolean_expr(fun(a, b));
+    }
+      Const_BinaryPredicate();
+    Func f;
+    First a;
+    Second b;
+  };
+  template < typename Func , typename Return > struct AdaptableGenerator; template < typename Func , typename Return > struct AdaptableGeneratorConcept : AdaptableGenerator< Func, Return > { }; template < typename Func , typename Return > struct AdaptableGenerator
+    : Generator<Func, typename Func::result_type>
+  {
+      typedef typename Func::result_type result_type;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AdaptableGenerator>)>::failed> boost_concept_check451; ~AdaptableGenerator()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check453;
+      }
+  };
+  template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunctionConcept : AdaptableUnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction
+    : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
+  {
+      typedef typename Func::argument_type argument_type;
+      typedef typename Func::result_type result_type;
+      ~AdaptableUnaryFunction()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check465;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Arg, argument_type>)>::failed> boost_concept_check466;
+      }
+  };
+  template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunctionConcept : AdaptableBinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction
+    : BinaryFunction<
+          Func
+        , typename Func::result_type
+        , typename Func::first_argument_type
+        , typename Func::second_argument_type
+      >
+  {
+      typedef typename Func::first_argument_type first_argument_type;
+      typedef typename Func::second_argument_type second_argument_type;
+      typedef typename Func::result_type result_type;
+      ~AdaptableBinaryFunction()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check484;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<First, first_argument_type>)>::failed> boost_concept_check485;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Second, second_argument_type>)>::failed> boost_concept_check486;
+      }
+  };
+  template < typename Func , typename Arg > struct AdaptablePredicate; template < typename Func , typename Arg > struct AdaptablePredicateConcept : AdaptablePredicate< Func, Arg > { }; template < typename Func , typename Arg > struct AdaptablePredicate
+    : UnaryPredicate<Func, Arg>
+    , AdaptableUnaryFunction<Func, bool, Arg>
+  {
+  };
+  template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicateConcept : AdaptableBinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate
+    : BinaryPredicate<Func, First, Second>
+    , AdaptableBinaryFunction<Func, bool, First, Second>
+  {
+  };
+  template < typename TT > struct InputIterator; template < typename TT > struct InputIteratorConcept : InputIterator< TT > { }; template < typename TT > struct InputIterator
+    : Assignable<TT>
+    , EqualityComparable<TT>
+  {
+      typedef typename boost::detail::iterator_traits<TT>::value_type value_type;
+      typedef typename boost::detail::iterator_traits<TT>::difference_type difference_type;
+      typedef typename boost::detail::iterator_traits<TT>::reference reference;
+      typedef typename boost::detail::iterator_traits<TT>::pointer pointer;
+      typedef typename boost::detail::iterator_traits<TT>::iterator_category iterator_category;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InputIterator>)>::failed> boost_concept_check515; ~InputIterator()
+      {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SignedInteger<difference_type>)>::failed> boost_concept_check517;
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<iterator_category, std::input_iterator_tag>)>::failed> boost_concept_check518;
+        TT j(i);
+        (void)*i;
+        ++j;
+        i++;
+      }
+   private:
+    TT i;
+  };
+  template < typename TT , typename ValueT > struct OutputIterator; template < typename TT , typename ValueT > struct OutputIteratorConcept : OutputIterator< TT, ValueT > { }; template < typename TT , typename ValueT > struct OutputIterator
+    : Assignable<TT>
+  {
+    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<OutputIterator>)>::failed> boost_concept_check532; ~OutputIterator() {
+      ++i;
+      i++;
+      *i++ = t;
+    }
+   private:
+    TT i, j;
+    ValueT t;
+  };
+  template < typename TT > struct ForwardIterator; template < typename TT > struct ForwardIteratorConcept : ForwardIterator< TT > { }; template < typename TT > struct ForwardIterator
+    : InputIterator<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIterator>)>::failed> boost_concept_check546; ~ForwardIterator()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename ForwardIterator::iterator_category , std::forward_iterator_tag >)>::failed>
+ boost_concept_check551;
+          typename InputIterator<TT>::reference r = *i;
+          ignore_unused_variable_warning(r);
+      }
+   private:
+      TT i;
+  };
+  template < typename TT > struct Mutable_ForwardIterator; template < typename TT > struct Mutable_ForwardIteratorConcept : Mutable_ForwardIterator< TT > { }; template < typename TT > struct Mutable_ForwardIterator
+    : ForwardIterator<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardIterator>)>::failed> boost_concept_check564; ~Mutable_ForwardIterator() {
+        *i++ = *i;
+      }
+   private:
+      TT i;
+  };
+  template < typename TT > struct BidirectionalIterator; template < typename TT > struct BidirectionalIteratorConcept : BidirectionalIterator< TT > { }; template < typename TT > struct BidirectionalIterator
+    : ForwardIterator<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIterator>)>::failed> boost_concept_check574; ~BidirectionalIterator()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator::iterator_category , std::bidirectional_iterator_tag >)>::failed>
+ boost_concept_check579;
+          --i;
+          i--;
+      }
+   private:
+      TT i;
+  };
+  template < typename TT > struct Mutable_BidirectionalIterator; template < typename TT > struct Mutable_BidirectionalIteratorConcept : Mutable_BidirectionalIterator< TT > { }; template < typename TT > struct Mutable_BidirectionalIterator
+    : BidirectionalIterator<TT>
+    , Mutable_ForwardIterator<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_BidirectionalIterator>)>::failed> boost_concept_check592; ~Mutable_BidirectionalIterator()
+      {
+          *i-- = *i;
+      }
+   private:
+      TT i;
+  };
+  template < typename TT > struct RandomAccessIterator; template < typename TT > struct RandomAccessIteratorConcept : RandomAccessIterator< TT > { }; template < typename TT > struct RandomAccessIterator
+    : BidirectionalIterator<TT>
+    , Comparable<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIterator>)>::failed> boost_concept_check604; ~RandomAccessIterator()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator<TT>::iterator_category , std::random_access_iterator_tag >)>::failed>
+ boost_concept_check609;
+          i += n;
+          i = i + n; i = n + i;
+          i -= n;
+          i = i - n;
+          n = i - j;
+          (void)i[n];
+      }
+   private:
+    TT a, b;
+    TT i, j;
+      typename boost::detail::iterator_traits<TT>::difference_type n;
+  };
+  template < typename TT > struct Mutable_RandomAccessIterator; template < typename TT > struct Mutable_RandomAccessIteratorConcept : Mutable_RandomAccessIterator< TT > { }; template < typename TT > struct Mutable_RandomAccessIterator
+    : RandomAccessIterator<TT>
+    , Mutable_BidirectionalIterator<TT>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessIterator>)>::failed> boost_concept_check629; ~Mutable_RandomAccessIterator()
+      {
+          i[n] = *i;
+      }
+   private:
+    TT i;
+    typename boost::detail::iterator_traits<TT>::difference_type n;
+  };
+  template < typename C > struct Container; template < typename C > struct ContainerConcept : Container< C > { }; template < typename C > struct Container
+    : Assignable<C>
+  {
+    typedef typename C::value_type value_type;
+    typedef typename C::difference_type difference_type;
+    typedef typename C::size_type size_type;
+    typedef typename C::const_reference const_reference;
+    typedef typename C::const_pointer const_pointer;
+    typedef typename C::const_iterator const_iterator;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Container>)>::failed> boost_concept_check651; ~Container()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<const_iterator>)>::failed> boost_concept_check653;
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc) {
+          i = cc.begin();
+          i = cc.end();
+          n = cc.size();
+          n = cc.max_size();
+          b = cc.empty();
+      }
+      C c;
+      bool b;
+      const_iterator i;
+      size_type n;
+  };
+  template < typename C > struct Mutable_Container; template < typename C > struct Mutable_ContainerConcept : Mutable_Container< C > { }; template < typename C > struct Mutable_Container
+    : Container<C>
+  {
+      typedef typename C::reference reference;
+      typedef typename C::iterator iterator;
+      typedef typename C::pointer pointer;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_Container>)>::failed> boost_concept_check678; ~Mutable_Container()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Assignable<typename Mutable_Container::value_type>)>::failed>
+ boost_concept_check681;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<iterator>)>::failed> boost_concept_check683;
+          i = c.begin();
+          i = c.end();
+          c.swap(c2);
+      }
+   private:
+      iterator i;
+      C c, c2;
+  };
+  template < typename C > struct ForwardContainer; template < typename C > struct ForwardContainerConcept : ForwardContainer< C > { }; template < typename C > struct ForwardContainer
+    : Container<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardContainer>)>::failed> boost_concept_check698; ~ForwardContainer()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( ForwardIterator< typename ForwardContainer::const_iterator >)>::failed>
+ boost_concept_check703;
+      }
+  };
+  template < typename C > struct Mutable_ForwardContainer; template < typename C > struct Mutable_ForwardContainerConcept : Mutable_ForwardContainer< C > { }; template < typename C > struct Mutable_ForwardContainer
+    : ForwardContainer<C>
+    , Mutable_Container<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardContainer>)>::failed> boost_concept_check711; ~Mutable_ForwardContainer()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Mutable_ForwardIterator< typename Mutable_ForwardContainer::iterator >)>::failed>
+ boost_concept_check716;
+      }
+  };
+  template < typename C > struct ReversibleContainer; template < typename C > struct ReversibleContainerConcept : ReversibleContainer< C > { }; template < typename C > struct ReversibleContainer
+    : ForwardContainer<C>
+  {
+      typedef typename
+        C::const_reverse_iterator
+      const_reverse_iterator;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReversibleContainer>)>::failed> boost_concept_check727; ~ReversibleContainer()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( BidirectionalIterator< typename ReversibleContainer::const_iterator>)>::failed>
+ boost_concept_check731;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BidirectionalIterator<const_reverse_iterator>)>::failed> boost_concept_check733;
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reverse_iterator i = cc.rbegin();
+          i = cc.rend();
+      }
+      C c;
+  };
+  template < typename C > struct Mutable_ReversibleContainer; template < typename C > struct Mutable_ReversibleContainerConcept : Mutable_ReversibleContainer< C > { }; template < typename C > struct Mutable_ReversibleContainer
+    : Mutable_ForwardContainer<C>
+    , ReversibleContainer<C>
+  {
+      typedef typename C::reverse_iterator reverse_iterator;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ReversibleContainer>)>::failed> boost_concept_check752; ~Mutable_ReversibleContainer()
+      {
+          typedef typename Mutable_ForwardContainer<C>::iterator iterator;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<iterator>)>::failed> boost_concept_check755;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<reverse_iterator>)>::failed> boost_concept_check756;
+          reverse_iterator i = c.rbegin();
+          i = c.rend();
+      }
+   private:
+      C c;
+  };
+  template < typename C > struct RandomAccessContainer; template < typename C > struct RandomAccessContainerConcept : RandomAccessContainer< C > { }; template < typename C > struct RandomAccessContainer
+    : ReversibleContainer<C>
+  {
+      typedef typename C::size_type size_type;
+      typedef typename C::const_reference const_reference;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessContainer>)>::failed> boost_concept_check771; ~RandomAccessContainer()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( RandomAccessIterator< typename RandomAccessContainer::const_iterator >)>::failed>
+ boost_concept_check776;
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const C& cc)
+      {
+          const_reference r = cc[n];
+          ignore_unused_variable_warning(r);
+      }
+      C c;
+      size_type n;
+  };
+  template < typename C > struct Mutable_RandomAccessContainer; template < typename C > struct Mutable_RandomAccessContainerConcept : Mutable_RandomAccessContainer< C > { }; template < typename C > struct Mutable_RandomAccessContainer
+    : Mutable_ReversibleContainer<C>
+    , RandomAccessContainer<C>
+  {
+   private:
+      typedef Mutable_RandomAccessContainer self;
+   public:
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessContainer>)>::failed> boost_concept_check798; ~Mutable_RandomAccessContainer()
+      {
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::iterator>)>::failed> boost_concept_check800;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::reverse_iterator>)>::failed> boost_concept_check801;
+          typename self::reference r = c[i];
+          ignore_unused_variable_warning(r);
+      }
+   private:
+      typename Mutable_ReversibleContainer<C>::size_type i;
+      C c;
+  };
+  template < typename S > struct Sequence; template < typename S > struct SequenceConcept : Sequence< S > { }; template < typename S > struct Sequence
+    : Mutable_ForwardContainer<S>
+    , DefaultConstructible<S>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Sequence>)>::failed> boost_concept_check820; ~Sequence()
+      {
+          S
+              c(n),
+              c2(n, t),
+              c3(first, last);
+          c.insert(p, t);
+          c.insert(p, n, t);
+          c.insert(p, first, last);
+          c.erase(p);
+          c.erase(p, q);
+          typename Sequence::reference r = c.front();
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& c) {
+          typename Sequence::const_reference r = c.front();
+          ignore_unused_variable_warning(r);
+      }
+      typename S::value_type t;
+      typename S::size_type n;
+      typename S::value_type* first, *last;
+      typename S::iterator p, q;
+  };
+  template < typename S > struct FrontInsertionSequence; template < typename S > struct FrontInsertionSequenceConcept : FrontInsertionSequence< S > { }; template < typename S > struct FrontInsertionSequence
+    : Sequence<S>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<FrontInsertionSequence>)>::failed> boost_concept_check857; ~FrontInsertionSequence()
+      {
+          c.push_front(t);
+          c.pop_front();
+      }
+   private:
+      S c;
+      typename S::value_type t;
+  };
+  template < typename S > struct BackInsertionSequence; template < typename S > struct BackInsertionSequenceConcept : BackInsertionSequence< S > { }; template < typename S > struct BackInsertionSequence
+    : Sequence<S>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BackInsertionSequence>)>::failed> boost_concept_check870; ~BackInsertionSequence()
+      {
+          c.push_back(t);
+          c.pop_back();
+          typename BackInsertionSequence::reference r = c.back();
+          ignore_unused_variable_warning(r);
+          const_constraints(c);
+      }
+   private:
+      void const_constraints(const S& cc) {
+          typename BackInsertionSequence::const_reference
+              r = cc.back();
+          ignore_unused_variable_warning(r);
+      };
+      S c;
+      typename S::value_type t;
+  };
+  template < typename C > struct AssociativeContainer; template < typename C > struct AssociativeContainerConcept : AssociativeContainer< C > { }; template < typename C > struct AssociativeContainer
+    : ForwardContainer<C>
+    , DefaultConstructible<C>
+  {
+      typedef typename C::key_type key_type;
+      typedef typename C::key_compare key_compare;
+      typedef typename C::value_compare value_compare;
+      typedef typename C::iterator iterator;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AssociativeContainer>)>::failed> boost_concept_check897; ~AssociativeContainer()
+      {
+          i = c.find(k);
+          r = c.equal_range(k);
+          c.erase(k);
+          c.erase(i);
+          c.erase(r.first, r.second);
+          const_constraints(c);
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<key_compare,key_type,key_type>)>::failed> boost_concept_check905;
+          typedef typename AssociativeContainer::value_type value_type_;
+          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<value_compare,value_type_,value_type_>)>::failed> boost_concept_check908;
+      }
+      typedef typename C::const_iterator const_iterator;
+   private:
+      void const_constraints(const C& cc)
+      {
+          ci = cc.find(k);
+          n = cc.count(k);
+          cr = cc.equal_range(k);
+      }
+      C c;
+      iterator i;
+      std::pair<iterator,iterator> r;
+      const_iterator ci;
+      std::pair<const_iterator,const_iterator> cr;
+      typename C::key_type k;
+      typename C::size_type n;
+  };
+  template < typename C > struct UniqueAssociativeContainer; template < typename C > struct UniqueAssociativeContainerConcept : UniqueAssociativeContainer< C > { }; template < typename C > struct UniqueAssociativeContainer
+    : AssociativeContainer<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UniqueAssociativeContainer>)>::failed> boost_concept_check933; ~UniqueAssociativeContainer()
+      {
+          C c(first, last);
+          pos_flag = c.insert(t);
+          c.insert(first, last);
+          ignore_unused_variable_warning(c);
+      }
+   private:
+      std::pair<typename C::iterator, bool> pos_flag;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+  template < typename C > struct MultipleAssociativeContainer; template < typename C > struct MultipleAssociativeContainerConcept : MultipleAssociativeContainer< C > { }; template < typename C > struct MultipleAssociativeContainer
+    : AssociativeContainer<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<MultipleAssociativeContainer>)>::failed> boost_concept_check951; ~MultipleAssociativeContainer()
+      {
+          C c(first, last);
+          pos = c.insert(t);
+          c.insert(first, last);
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(pos);
+      }
+   private:
+      typename C::iterator pos;
+      typename C::value_type t;
+      typename C::value_type* first, *last;
+  };
+  template < typename C > struct SimpleAssociativeContainer; template < typename C > struct SimpleAssociativeContainerConcept : SimpleAssociativeContainer< C > { }; template < typename C > struct SimpleAssociativeContainer
+    : AssociativeContainer<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SimpleAssociativeContainer>)>::failed> boost_concept_check970; ~SimpleAssociativeContainer()
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          enum { mpl_assertion_in_line_974 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<key_type,value_type>))0, 1 ) ) ) };
+      }
+  };
+  template < typename C > struct PairAssociativeContainer; template < typename C > struct PairAssociativeContainerConcept : PairAssociativeContainer< C > { }; template < typename C > struct PairAssociativeContainer
+    : AssociativeContainer<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PairAssociativeContainer>)>::failed> boost_concept_check981; ~PairAssociativeContainer()
+      {
+          typedef typename C::key_type key_type;
+          typedef typename C::value_type value_type;
+          typedef typename C::mapped_type mapped_type;
+          typedef std::pair<const key_type, mapped_type> required_value_type;
+          enum { mpl_assertion_in_line_987 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_same<value_type,required_value_type>))0, 1 ) ) ) };
+      }
+  };
+  template < typename C > struct SortedAssociativeContainer; template < typename C > struct SortedAssociativeContainerConcept : SortedAssociativeContainer< C > { }; template < typename C > struct SortedAssociativeContainer
+    : AssociativeContainer<C>
+    , ReversibleContainer<C>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SortedAssociativeContainer>)>::failed> boost_concept_check995; ~SortedAssociativeContainer()
+      {
+          C
+              c(kc),
+              c2(first, last),
+              c3(first, last, kc);
+          p = c.upper_bound(k);
+          p = c.lower_bound(k);
+          r = c.equal_range(k);
+          c.insert(p, t);
+          ignore_unused_variable_warning(c);
+          ignore_unused_variable_warning(c2);
+          ignore_unused_variable_warning(c3);
+          const_constraints(c);
+      }
+      void const_constraints(const C& c)
+      {
+          kc = c.key_comp();
+          vc = c.value_comp();
+          cp = c.upper_bound(k);
+          cp = c.lower_bound(k);
+          cr = c.equal_range(k);
+      }
+   private:
+      typename C::key_compare kc;
+      typename C::value_compare vc;
+      typename C::value_type t;
+      typename C::key_type k;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef SortedAssociativeContainer self;
+      iterator p;
+      const_iterator cp;
+      std::pair<typename self::iterator,typename self::iterator> r;
+      std::pair<typename self::const_iterator,typename self::const_iterator> cr;
+      typename C::value_type* first, *last;
+  };
+  template < typename C > struct Collection; template < typename C > struct CollectionConcept : Collection< C > { }; template < typename C > struct Collection
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Collection>)>::failed> boost_concept_check1044; ~Collection()
+      {
+        boost::function_requires<boost::InputIteratorConcept<iterator> >();
+        boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+        boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
+        const_constraints(c);
+        i = c.begin();
+        i = c.end();
+        c.swap(c);
+      }
+      void const_constraints(const C& c) {
+        ci = c.begin();
+        ci = c.end();
+        n = c.size();
+        b = c.empty();
+      }
+    private:
+      typedef typename C::value_type value_type;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef typename C::reference reference;
+      typedef typename C::const_reference const_reference;
+      typedef typename C::difference_type difference_type;
+      typedef typename C::size_type size_type;
+      C c;
+      bool b;
+      iterator i;
+      const_iterator ci;
+      size_type n;
+  };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+  enum float_denorm_style
+  {
+    denorm_indeterminate = -1,
+    denorm_absent = 0,
+    denorm_present = 1
+  };
+  struct __numeric_limits_base
+  {
+    static const bool is_specialized = false;
+    static const int digits = 0;
+    static const int digits10 = 0;
+    static const bool is_signed = false;
+    static const bool is_integer = false;
+    static const bool is_exact = false;
+    static const int radix = 0;
+    static const int min_exponent = 0;
+    static const int min_exponent10 = 0;
+    static const int max_exponent = 0;
+    static const int max_exponent10 = 0;
+    static const bool has_infinity = false;
+    static const bool has_quiet_NaN = false;
+    static const bool has_signaling_NaN = false;
+    static const float_denorm_style has_denorm = denorm_absent;
+    static const bool has_denorm_loss = false;
+    static const bool is_iec559 = false;
+    static const bool is_bounded = false;
+    static const bool is_modulo = false;
+    static const bool traps = false;
+    static const bool tinyness_before = false;
+    static const float_round_style round_style =
+          round_toward_zero;
+  };
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+      static _Tp
+      min() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      max() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      epsilon() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      round_error() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      infinity() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      quiet_NaN() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      signaling_NaN() throw() { return static_cast<_Tp>(0); }
+      static _Tp
+      denorm_min() throw() { return static_cast<_Tp>(0); }
+    };
+  template<>
+    struct numeric_limits<bool>
+    {
+      static const bool is_specialized = true;
+      static bool
+      min() throw() { return false; }
+      static bool
+      max() throw() { return true; }
+      static const int digits = 1;
+      static const int digits10 = 0;
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static bool
+      epsilon() throw() { return false; }
+      static bool
+      round_error() throw() { return false; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static bool
+      infinity() throw() { return false; }
+      static bool
+      quiet_NaN() throw() { return false; }
+      static bool
+      signaling_NaN() throw() { return false; }
+      static bool
+      denorm_min() throw() { return false; }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<char>
+    {
+      static const bool is_specialized = true;
+      static char
+      min() throw() { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
+      static char
+      max() throw() { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
+      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
+      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = ((char)(-1) < 0);
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static char
+      epsilon() throw() { return 0; }
+      static char
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static
+      char infinity() throw() { return char(); }
+      static char
+      quiet_NaN() throw() { return char(); }
+      static char
+      signaling_NaN() throw() { return char(); }
+      static char
+      denorm_min() throw() { return static_cast<char>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static const bool is_specialized = true;
+      static signed char
+      min() throw() { return -127 - 1; }
+      static signed char
+      max() throw() { return 127; }
+      static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
+      static const int digits10
+       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static signed char
+      epsilon() throw() { return 0; }
+      static signed char
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static signed char
+      infinity() throw() { return static_cast<signed char>(0); }
+      static signed char
+      quiet_NaN() throw() { return static_cast<signed char>(0); }
+      static signed char
+      signaling_NaN() throw() { return static_cast<signed char>(0); }
+      static signed char
+      denorm_min() throw() { return static_cast<signed char>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static const bool is_specialized = true;
+      static unsigned char
+      min() throw() { return 0; }
+      static unsigned char
+      max() throw() { return 127 * 2U + 1; }
+      static const int digits
+       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
+      static const int digits10
+       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned char
+      epsilon() throw() { return 0; }
+      static unsigned char
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static unsigned char
+      infinity() throw() { return static_cast<unsigned char>(0); }
+      static unsigned char
+      quiet_NaN() throw() { return static_cast<unsigned char>(0); }
+      static unsigned char
+      signaling_NaN() throw() { return static_cast<unsigned char>(0); }
+      static unsigned char
+      denorm_min() throw() { return static_cast<unsigned char>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static const bool is_specialized = true;
+      static wchar_t
+      min() throw() { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
+      static wchar_t
+      max() throw() { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
+      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
+      static const int digits10
+       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = ((wchar_t)(-1) < 0);
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static wchar_t
+      epsilon() throw() { return 0; }
+      static wchar_t
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static wchar_t
+      infinity() throw() { return wchar_t(); }
+      static wchar_t
+      quiet_NaN() throw() { return wchar_t(); }
+      static wchar_t
+      signaling_NaN() throw() { return wchar_t(); }
+      static wchar_t
+      denorm_min() throw() { return wchar_t(); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<short>
+    {
+      static const bool is_specialized = true;
+      static short
+      min() throw() { return -32767 - 1; }
+      static short
+      max() throw() { return 32767; }
+      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
+      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static short
+      epsilon() throw() { return 0; }
+      static short
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static short
+      infinity() throw() { return short(); }
+      static short
+      quiet_NaN() throw() { return short(); }
+      static short
+      signaling_NaN() throw() { return short(); }
+      static short
+      denorm_min() throw() { return short(); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static const bool is_specialized = true;
+      static unsigned short
+      min() throw() { return 0; }
+      static unsigned short
+      max() throw() { return 32767 * 2U + 1; }
+      static const int digits
+       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
+      static const int digits10
+       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned short
+      epsilon() throw() { return 0; }
+      static unsigned short
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static unsigned short
+      infinity() throw() { return static_cast<unsigned short>(0); }
+      static unsigned short
+      quiet_NaN() throw() { return static_cast<unsigned short>(0); }
+      static unsigned short
+      signaling_NaN() throw() { return static_cast<unsigned short>(0); }
+      static unsigned short
+      denorm_min() throw() { return static_cast<unsigned short>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<int>
+    {
+      static const bool is_specialized = true;
+      static int
+      min() throw() { return -2147483647 - 1; }
+      static int
+      max() throw() { return 2147483647; }
+      static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
+      static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static int
+      epsilon() throw() { return 0; }
+      static int
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static int
+      infinity() throw() { return static_cast<int>(0); }
+      static int
+      quiet_NaN() throw() { return static_cast<int>(0); }
+      static int
+      signaling_NaN() throw() { return static_cast<int>(0); }
+      static int
+      denorm_min() throw() { return static_cast<int>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static const bool is_specialized = true;
+      static unsigned int
+      min() throw() { return 0; }
+      static unsigned int
+      max() throw() { return 2147483647 * 2U + 1; }
+      static const int digits
+       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
+      static const int digits10
+       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned int
+      epsilon() throw() { return 0; }
+      static unsigned int
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static unsigned int
+      infinity() throw() { return static_cast<unsigned int>(0); }
+      static unsigned int
+      quiet_NaN() throw() { return static_cast<unsigned int>(0); }
+      static unsigned int
+      signaling_NaN() throw() { return static_cast<unsigned int>(0); }
+      static unsigned int
+      denorm_min() throw() { return static_cast<unsigned int>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<long>
+    {
+      static const bool is_specialized = true;
+      static long
+      min() throw() { return -9223372036854775807L - 1; }
+      static long
+      max() throw() { return 9223372036854775807L; }
+      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
+      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static long
+      epsilon() throw() { return 0; }
+      static long
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static long
+      infinity() throw() { return static_cast<long>(0); }
+      static long
+      quiet_NaN() throw() { return static_cast<long>(0); }
+      static long
+      signaling_NaN() throw() { return static_cast<long>(0); }
+      static long
+      denorm_min() throw() { return static_cast<long>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static const bool is_specialized = true;
+      static unsigned long
+      min() throw() { return 0; }
+      static unsigned long
+      max() throw() { return 9223372036854775807L * 2UL + 1; }
+      static const int digits
+       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
+      static const int digits10
+       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned long
+      epsilon() throw() { return 0; }
+      static unsigned long
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static unsigned long
+      infinity() throw() { return static_cast<unsigned long>(0); }
+      static unsigned long
+      quiet_NaN() throw() { return static_cast<unsigned long>(0); }
+      static unsigned long
+      signaling_NaN() throw() { return static_cast<unsigned long>(0); }
+      static unsigned long
+      denorm_min() throw() { return static_cast<unsigned long>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<long long>
+    {
+      static const bool is_specialized = true;
+      static long long
+      min() throw() { return -9223372036854775807LL - 1; }
+      static long long
+      max() throw() { return 9223372036854775807LL; }
+      static const int digits
+       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
+      static const int digits10
+       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static long long
+      epsilon() throw() { return 0; }
+      static long long
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static long long
+      infinity() throw() { return static_cast<long long>(0); }
+      static long long
+      quiet_NaN() throw() { return static_cast<long long>(0); }
+      static long long
+      signaling_NaN() throw() { return static_cast<long long>(0); }
+      static long long
+      denorm_min() throw() { return static_cast<long long>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static const bool is_specialized = true;
+      static unsigned long long
+      min() throw() { return 0; }
+      static unsigned long long
+      max() throw() { return 9223372036854775807LL * 2ULL + 1; }
+      static const int digits
+       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
+      static const int digits10
+       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned long long
+      epsilon() throw() { return 0; }
+      static unsigned long long
+      round_error() throw() { return 0; }
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm
+       = denorm_absent;
+      static const bool has_denorm_loss = false;
+      static unsigned long long
+      infinity() throw() { return static_cast<unsigned long long>(0); }
+      static unsigned long long
+      quiet_NaN() throw() { return static_cast<unsigned long long>(0); }
+      static unsigned long long
+      signaling_NaN() throw() { return static_cast<unsigned long long>(0); }
+      static unsigned long long
+      denorm_min() throw() { return static_cast<unsigned long long>(0); }
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<float>
+    {
+      static const bool is_specialized = true;
+      static float
+      min() throw() { return 1.17549435082228750796873653722225e-38F; }
+      static float
+      max() throw() { return 3.40282346638528859811704183484517e+38F; }
+      static const int digits = 24;
+      static const int digits10 = 6;
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static float
+      epsilon() throw() { return 1.19209289550781250000000000000000e-7F; }
+      static float
+      round_error() throw() { return 0.5F; }
+      static const int min_exponent = (-125);
+      static const int min_exponent10 = (-37);
+      static const int max_exponent = 128;
+      static const int max_exponent10 = 38;
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss
+       = false;
+      static float
+      infinity() throw() { return __builtin_huge_valf (); }
+      static float
+      quiet_NaN() throw() { return __builtin_nanf (""); }
+      static float
+      signaling_NaN() throw() { return __builtin_nansf (""); }
+      static float
+      denorm_min() throw() { return 1.40129846432481707092372958328992e-45F; }
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+      static const bool traps = false;
+      static const bool tinyness_before
+       = false;
+      static const float_round_style round_style
+       = round_to_nearest;
+    };
+  template<>
+    struct numeric_limits<double>
+    {
+      static const bool is_specialized = true;
+      static double
+      min() throw() { return double(2.22507385850720138309023271733240e-308L); }
+      static double
+      max() throw() { return double(1.79769313486231570814527423731704e+308L); }
+      static const int digits = 53;
+      static const int digits10 = 15;
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static double
+      epsilon() throw() { return double(2.22044604925031308084726333618164e-16L); }
+      static double
+      round_error() throw() { return 0.5; }
+      static const int min_exponent = (-1021);
+      static const int min_exponent10 = (-307);
+      static const int max_exponent = 1024;
+      static const int max_exponent10 = 308;
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss
+        = false;
+      static double
+      infinity() throw() { return __builtin_huge_val(); }
+      static double
+      quiet_NaN() throw() { return __builtin_nan (""); }
+      static double
+      signaling_NaN() throw() { return __builtin_nans (""); }
+      static double
+      denorm_min() throw() { return double(4.94065645841246544176568792868221e-324L); }
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+      static const bool traps = false;
+      static const bool tinyness_before
+       = false;
+      static const float_round_style round_style
+       = round_to_nearest;
+    };
+  template<>
+    struct numeric_limits<long double>
+    {
+      static const bool is_specialized = true;
+      static long double
+      min() throw() { return 2.00416836000897277799610805135016e-292L; }
+      static long double
+      max() throw() { return 1.79769313486231580793728971405301e+308L; }
+      static const int digits = 106;
+      static const int digits10 = 31;
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static long double
+      epsilon() throw() { return 4.94065645841246544176568792868221e-324L; }
+      static long double
+      round_error() throw() { return 0.5L; }
+      static const int min_exponent = (-968);
+      static const int min_exponent10 = (-291);
+      static const int max_exponent = 1024;
+      static const int max_exponent10 = 308;
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss
+ = false;
+      static long double
+      infinity() throw() { return __builtin_huge_vall (); }
+      static long double
+      quiet_NaN() throw() { return __builtin_nanl (""); }
+      static long double
+      signaling_NaN() throw() { return __builtin_nansl (""); }
+      static long double
+      denorm_min() throw() { return 4.94065645841246544176568792868221e-324L; }
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+      static const bool traps = false;
+      static const bool tinyness_before =
+      false;
+      static const float_round_style round_style =
+            round_to_nearest;
+    };
+}
+namespace boost_concepts
+{
+  template < typename Iterator > struct ReadableIterator; template < typename Iterator > struct ReadableIteratorConcept : ReadableIterator< Iterator > { }; template < typename Iterator > struct ReadableIterator
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef typename boost::detail::iterator_traits<Iterator>::reference reference;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReadableIterator>)>::failed> boost_concept_check50; ~ReadableIterator()
+      {
+          value_type v = *i;
+          boost::ignore_unused_variable_warning(v);
+      }
+  private:
+      Iterator i;
+  };
+  template <
+      typename Iterator
+    , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIterator
+    : boost::CopyConstructible<Iterator>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WritableIterator>)>::failed> boost_concept_check67; ~WritableIterator()
+      {
+          *i = v;
+      }
+  private:
+      ValueType v;
+      Iterator i;
+  };
+  template <
+      typename Iterator
+    , typename ValueType = typename boost::detail::iterator_traits<Iterator>::value_type
+  >
+  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
+  template < typename Iterator > struct SwappableIterator; template < typename Iterator > struct SwappableIteratorConcept : SwappableIterator< Iterator > { }; template < typename Iterator > struct SwappableIterator
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SwappableIterator>)>::failed> boost_concept_check84; ~SwappableIterator()
+      {
+          std::iter_swap(i1, i2);
+      }
+  private:
+      Iterator i1;
+      Iterator i2;
+  };
+  template < typename Iterator > struct LvalueIterator; template < typename Iterator > struct LvalueIteratorConcept : LvalueIterator< Iterator > { }; template < typename Iterator > struct LvalueIterator
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LvalueIterator>)>::failed> boost_concept_check97; ~LvalueIterator()
+      {
+        value_type& r = const_cast<value_type&>(*i);
+        boost::ignore_unused_variable_warning(r);
+      }
+  private:
+      Iterator i;
+  };
+  template < typename Iterator > struct IncrementableIterator; template < typename Iterator > struct IncrementableIteratorConcept : IncrementableIterator< Iterator > { }; template < typename Iterator > struct IncrementableIterator
+    : boost::Assignable<Iterator>
+    , boost::CopyConstructible<Iterator>
+  {
+      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >)>::failed>
+ boost_concept_check120;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIterator>)>::failed> boost_concept_check122; ~IncrementableIterator()
+      {
+          ++i;
+          (void)i++;
+      }
+  private:
+      Iterator i;
+  };
+  template < typename Iterator > struct SinglePassIterator; template < typename Iterator > struct SinglePassIteratorConcept : SinglePassIterator< Iterator > { }; template < typename Iterator > struct SinglePassIterator
+    : IncrementableIterator<Iterator>
+    , boost::EqualityComparable<Iterator>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > )>::failed>
+ boost_concept_check140;
+  };
+  template < typename Iterator > struct ForwardTraversal; template < typename Iterator > struct ForwardTraversalConcept : ForwardTraversal< Iterator > { }; template < typename Iterator > struct ForwardTraversal
+    : SinglePassIterator<Iterator>
+    , boost::DefaultConstructible<Iterator>
+  {
+      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+      enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (boost::is_integral<difference_type>))0, 1 ) ) ) };
+      enum { mpl_assert_rel_value150 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_150 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value150>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , std::numeric_limits<difference_type>::is_signed , true >::************)) 0 ) ) };
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > )>::failed>
+ boost_concept_check156;
+  };
+  template < typename Iterator > struct BidirectionalTraversal; template < typename Iterator > struct BidirectionalTraversalConcept : BidirectionalTraversal< Iterator > { }; template < typename Iterator > struct BidirectionalTraversal
+    : ForwardTraversal<Iterator>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > )>::failed>
+ boost_concept_check166;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalTraversal>)>::failed> boost_concept_check168; ~BidirectionalTraversal()
+      {
+          --i;
+          (void)i--;
+      }
+   private:
+      Iterator i;
+  };
+  template < typename Iterator > struct RandomAccessTraversal; template < typename Iterator > struct RandomAccessTraversalConcept : RandomAccessTraversal< Iterator > { }; template < typename Iterator > struct RandomAccessTraversal
+    : BidirectionalTraversal<Iterator>
+  {
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > )>::failed>
+ boost_concept_check184;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessTraversal>)>::failed> boost_concept_check186; ~RandomAccessTraversal()
+      {
+          i += n;
+          i = i + n;
+          i = n + i;
+          i -= n;
+          i = i - n;
+          n = i - j;
+      }
+   private:
+      typename BidirectionalTraversal<Iterator>::difference_type n;
+      Iterator i, j;
+  };
+  namespace detail
+  {
+    template <typename Iterator1, typename Iterator2>
+    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
+    {
+        bool b;
+        b = i1 == i2;
+        b = i1 != i2;
+        b = i2 == i1;
+        b = i2 != i1;
+        boost::ignore_unused_variable_warning(b);
+    }
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const& i1, Iterator2 const& i2,
+        boost::random_access_traversal_tag, boost::random_access_traversal_tag)
+    {
+        bool b;
+        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+        b = i1 < i2;
+        b = i1 <= i2;
+        b = i1 > i2;
+        b = i1 >= i2;
+        n = i1 - i2;
+        b = i2 < i1;
+        b = i2 <= i1;
+        b = i2 > i1;
+        b = i2 >= i1;
+        n = i2 - i1;
+        boost::ignore_unused_variable_warning(b);
+        boost::ignore_unused_variable_warning(n);
+    }
+    template <typename Iterator1, typename Iterator2>
+    void interop_rand_access_constraints(
+        Iterator1 const&, Iterator2 const&,
+        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
+    { }
+  }
+  template < typename Iterator , typename ConstIterator > struct InteroperableIterator; template < typename Iterator , typename ConstIterator > struct InteroperableIteratorConcept : InteroperableIterator< Iterator, ConstIterator > { }; template < typename Iterator , typename ConstIterator > struct InteroperableIterator
+  {
+   private:
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              Iterator
+          >::type
+      >::type traversal_category;
+      typedef typename boost::detail::pure_traversal_tag<
+          typename boost::iterator_traversal<
+              ConstIterator
+          >::type
+      >::type const_traversal_category;
+  public:
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<Iterator>)>::failed> boost_concept_check264;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<ConstIterator>)>::failed> boost_concept_check265;
+      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InteroperableIterator>)>::failed> boost_concept_check267; ~InteroperableIterator()
+      {
+          detail::interop_single_pass_constraints(i, ci);
+          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());
+          ci = i;
+      }
+   private:
+      Iterator i;
+      ConstIterator ci;
+  };
+}
+namespace boost
+{
+    template< class T >
+    struct range_value : iterator_value< typename range_iterator<T>::type >
+    { };
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        template<typename T1, typename T2>
+        class SameTypeConcept
+        {
+        public:
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SameTypeConcept>)>::failed> boost_concept_check21; ~SameTypeConcept()
+            {
+                same_type(a,b);
+            }
+        private:
+            template<typename T> void same_type(T,T) {}
+            T1 a;
+            T2 b;
+        };
+    }
+}
+namespace boost {
+    namespace range_detail {
+        template<class Iterator>
+        struct IncrementableIteratorConcept : CopyConstructible<Iterator>
+        {
+            typedef typename iterator_traversal<Iterator>::type traversal_category;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< traversal_category, incrementable_traversal_tag >)>::failed>
+ boost_concept_check122;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIteratorConcept>)>::failed> boost_concept_check124; ~IncrementableIteratorConcept()
+            {
+                ++i;
+                (void)i++;
+            }
+        private:
+            Iterator i;
+        };
+        template<class Iterator>
+        struct SinglePassIteratorConcept
+            : IncrementableIteratorConcept<Iterator>
+            , EqualityComparable<Iterator>
+        {
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename SinglePassIteratorConcept::traversal_category, single_pass_traversal_tag >)>::failed>
+ boost_concept_check144;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassIteratorConcept>)>::failed> boost_concept_check146; ~SinglePassIteratorConcept()
+            {
+                Iterator i2(++i);
+                boost::ignore_unused_variable_warning(i2);
+                (void)(i++);
+                typename boost::detail::iterator_traits<Iterator>::reference r1(*i);
+                boost::ignore_unused_variable_warning(r1);
+                typename boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
+                boost::ignore_unused_variable_warning(r2);
+            }
+        private:
+            Iterator i;
+        };
+        template<class Iterator>
+        struct ForwardIteratorConcept
+            : SinglePassIteratorConcept<Iterator>
+            , DefaultConstructible<Iterator>
+        {
+            typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+            enum { mpl_assertion_in_line_176 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_integral<difference_type>))0, 1 ) ) ) };
+            enum { mpl_assert_rel_value177 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_177 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value177>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , std::numeric_limits<difference_type>::is_signed , true >::************)) 0 ) ) };
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename ForwardIteratorConcept::traversal_category, forward_traversal_tag >)>::failed>
+ boost_concept_check183;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIteratorConcept>)>::failed> boost_concept_check185; ~ForwardIteratorConcept()
+            {
+                Iterator i2(i++);
+                boost::ignore_unused_variable_warning(i2);
+                typename boost::detail::iterator_traits<Iterator>::reference r(*(i++));
+                boost::ignore_unused_variable_warning(r);
+            }
+        private:
+            Iterator i;
+         };
+         template<class Iterator>
+         struct BidirectionalIteratorConcept
+             : ForwardIteratorConcept<Iterator>
+         {
+             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename BidirectionalIteratorConcept::traversal_category, bidirectional_traversal_tag >)>::failed>
+ boost_concept_check210;
+             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIteratorConcept>)>::failed> boost_concept_check212; ~BidirectionalIteratorConcept()
+             {
+                 --i;
+                 (void)i--;
+             }
+         private:
+             Iterator i;
+         };
+         template<class Iterator>
+         struct RandomAccessIteratorConcept
+             : BidirectionalIteratorConcept<Iterator>
+         {
+             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename RandomAccessIteratorConcept::traversal_category, random_access_traversal_tag >)>::failed>
+ boost_concept_check231;
+             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIteratorConcept>)>::failed> boost_concept_check233; ~RandomAccessIteratorConcept()
+             {
+                 i += n;
+                 i = i + n;
+                 i = n + i;
+                 i -= n;
+                 i = i - n;
+                 n = i - j;
+             }
+         private:
+             typename RandomAccessIteratorConcept::difference_type n;
+             Iterator i;
+             Iterator j;
+         };
+    }
+    template<class T>
+    struct SinglePassRangeConcept
+    {
+         typedef typename range_iterator<T const>::type const_iterator;
+         typedef typename range_iterator<T>::type iterator;
+         typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::SinglePassIteratorConcept<iterator>)>::failed> boost_concept_check259;
+         typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::SinglePassIteratorConcept<const_iterator>)>::failed> boost_concept_check260;
+         typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassRangeConcept>)>::failed> boost_concept_check262; ~SinglePassRangeConcept()
+         {
+            iterator i1 = boost::begin(*m_range);
+            iterator i2 = boost::end(*m_range);
+            ignore_unused_variable_warning(i1);
+            ignore_unused_variable_warning(i2);
+            const_constraints(*m_range);
+        }
+    private:
+        void const_constraints(const T& const_range)
+        {
+            const_iterator ci1 = boost::begin(const_range);
+            const_iterator ci2 = boost::end(const_range);
+            ignore_unused_variable_warning(ci1);
+            ignore_unused_variable_warning(ci2);
+        }
+       T* m_range;
+    };
+    template<class T>
+    struct ForwardRangeConcept : SinglePassRangeConcept<T>
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>)>::failed> boost_concept_check299;
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>)>::failed> boost_concept_check300;
+    };
+    template<class Range>
+    struct WriteableRangeConcept
+    {
+        typedef typename range_iterator<Range>::type iterator;
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WriteableRangeConcept>)>::failed> boost_concept_check310; ~WriteableRangeConcept()
+        {
+            *i = v;
+        }
+    private:
+        iterator i;
+        typename range_value<Range>::type v;
+    };
+    template<class T>
+    struct WriteableForwardRangeConcept
+        : ForwardRangeConcept<T>
+        , WriteableRangeConcept<T>
+    {
+    };
+    template<class T>
+    struct BidirectionalRangeConcept : ForwardRangeConcept<T>
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>)>::failed> boost_concept_check333;
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>)>::failed> boost_concept_check334;
+    };
+    template<class T>
+    struct WriteableBidirectionalRangeConcept
+        : BidirectionalRangeConcept<T>
+        , WriteableRangeConcept<T>
+    {
+    };
+    template<class T>
+    struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>)>::failed> boost_concept_check351;
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>)>::failed> boost_concept_check352;
+    };
+    template<class T>
+    struct WriteableRandomAccessRangeConcept
+        : RandomAccessRangeConcept<T>
+        , WriteableRangeConcept<T>
+    {
+    };
+}
+namespace boost
+{
+    namespace range_detail
+    {
+        template< class SinglePassTraversalReadableIterator1,
+                  class SinglePassTraversalReadableIterator2,
+                  class IteratorCategoryTag1,
+                  class IteratorCategoryTag2 >
+        inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+                                SinglePassTraversalReadableIterator1 last1,
+                                SinglePassTraversalReadableIterator2 first2,
+                                SinglePassTraversalReadableIterator2 last2,
+                                IteratorCategoryTag1,
+                                IteratorCategoryTag2 )
+        {
+            do
+            {
+                if (first1 == last1)
+                    return first2 == last2;
+                if (first2 == last2)
+                    return false;
+            } while(*first1++ == *first2++);
+            return false;
+        }
+        template< class SinglePassTraversalReadableIterator1,
+                  class SinglePassTraversalReadableIterator2,
+                  class IteratorCategoryTag1,
+                  class IteratorCategoryTag2,
+                  class BinaryPredicate >
+        inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+                                SinglePassTraversalReadableIterator1 last1,
+                                SinglePassTraversalReadableIterator2 first2,
+                                SinglePassTraversalReadableIterator2 last2,
+                                BinaryPredicate pred,
+                                IteratorCategoryTag1,
+                                IteratorCategoryTag2 )
+        {
+            do
+            {
+                if (first1 == last1)
+                    return first2 == last2;
+                if (first2 == last2)
+                    return false;
+            } while(pred(*first1++, *first2++));
+            return false;
+        }
+        template< class RandomAccessTraversalReadableIterator1,
+                  class RandomAccessTraversalReadableIterator2 >
+        inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+                                RandomAccessTraversalReadableIterator1 last1,
+                                RandomAccessTraversalReadableIterator2 first2,
+                                RandomAccessTraversalReadableIterator2 last2,
+                                std::random_access_iterator_tag,
+                                std::random_access_iterator_tag )
+        {
+            return ((last1 - first1) == (last2 - first2))
+                && std::equal(first1, last1, first2);
+        }
+        template< class RandomAccessTraversalReadableIterator1,
+                  class RandomAccessTraversalReadableIterator2,
+                  class BinaryPredicate >
+        inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+                                RandomAccessTraversalReadableIterator1 last1,
+                                RandomAccessTraversalReadableIterator2 first2,
+                                RandomAccessTraversalReadableIterator2 last2,
+                                BinaryPredicate pred )
+        {
+            return ((last1 - first1) == (last2 - first2))
+                && std::equal(first1, last1, first2, pred);
+        }
+        template< class SinglePassTraversalReadableIterator1,
+                  class SinglePassTraversalReadableIterator2 >
+        inline bool equal( SinglePassTraversalReadableIterator1 first1,
+                           SinglePassTraversalReadableIterator1 last1,
+                           SinglePassTraversalReadableIterator2 first2,
+                           SinglePassTraversalReadableIterator2 last2 )
+        {
+            typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+            typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+            return equal_impl(first1, last1, first2, last2, tag1, tag2);
+        }
+        template< class SinglePassTraversalReadableIterator1,
+                  class SinglePassTraversalReadableIterator2,
+                  class BinaryPredicate >
+        inline bool equal( SinglePassTraversalReadableIterator1 first1,
+                           SinglePassTraversalReadableIterator1 last1,
+                           SinglePassTraversalReadableIterator2 first2,
+                           SinglePassTraversalReadableIterator2 last2,
+                           BinaryPredicate pred )
+        {
+            typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+            typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+            return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
+        }
+    }
+    namespace range
+    {
+        template< class SinglePassRange1, class SinglePassRange2 >
+        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
+        {
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check162;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check163;
+            return ::boost::range_detail::equal(
+                ::boost::begin(rng1), ::boost::end(rng1),
+                ::boost::begin(rng2), ::boost::end(rng2) );
+        }
+        template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+                           BinaryPredicate pred )
+        {
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check175;
+            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check176;
+            return ::boost::range_detail::equal(
+                ::boost::begin(rng1), ::boost::end(rng1),
+                ::boost::begin(rng2), ::boost::end(rng2),
+                pred);
+        }
+    }
+    using range::equal;
+}
+namespace boost
+{
+    namespace range_detail
+    {
+template<class DataMemberPtr>
+class safe_bool
+{
+public:
+    typedef safe_bool this_type;
+    typedef DataMemberPtr unspecified_bool_type;
+    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p)
+    {
+        return x ? p : 0;
+    }
+private:
+    safe_bool();
+    safe_bool(const safe_bool&);
+    void operator=(const safe_bool&);
+    ~safe_bool();
+};
+    }
+}
+namespace boost
+{
+    namespace iterator_range_detail
+    {
+        template<class IteratorT>
+        struct iterator_range_impl {
+            template< class ForwardRange >
+            static IteratorT adl_begin( ForwardRange& r )
+            {
+                return static_cast<IteratorT>( boost::begin( r ) );
+            }
+            template< class ForwardRange >
+            static IteratorT adl_end( ForwardRange& r )
+            {
+                return static_cast<IteratorT>( boost::end( r ) );
+            }
+        };
+        template< class Left, class Right >
+        inline bool less_than( const Left& l, const Right& r )
+        {
+            return std::lexicographical_compare( boost::begin(l),
+                                                 boost::end(l),
+                                                 boost::begin(r),
+                                                 boost::end(r) );
+        }
+        template< class Left, class Right >
+        inline bool greater_than( const Left& l, const Right& r )
+        {
+            return less_than(r,l);
+        }
+        template< class Left, class Right >
+        inline bool less_or_equal_than( const Left& l, const Right& r )
+        {
+            return !iterator_range_detail::less_than(r,l);
+        }
+        template< class Left, class Right >
+        inline bool greater_or_equal_than( const Left& l, const Right& r )
+        {
+            return !iterator_range_detail::less_than(l,r);
+        }
+        template< class Left, class Right >
+        inline bool equal(const Left& l, const Right& r)
+        {
+            return boost::equal(l, r);
+        }
+        struct range_tag { };
+        struct const_range_tag { };
+    }
+        template<class IteratorT>
+        class iterator_range
+        {
+            typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t;
+        protected:
+            typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
+        public:
+            typedef iterator_range<IteratorT> type;
+            typedef typename safe_bool_t::unspecified_bool_type unspecified_bool_type;
+            typedef typename
+                iterator_value<IteratorT>::type value_type;
+            typedef typename
+                iterator_difference<IteratorT>::type difference_type;
+            typedef std::size_t size_type;
+            typedef iterator_range<IteratorT> this_type;
+            typedef typename
+                iterator_reference<IteratorT>::type reference;
+            typedef IteratorT const_iterator;
+            typedef IteratorT iterator;
+        private:
+            typedef typename
+                boost::mpl::if_< boost::is_abstract<value_type>,
+                                 reference, value_type >::type abstract_value_type;
+        public:
+            iterator_range() : m_Begin( iterator() ), m_End( iterator() )
+            { }
+            template< class Iterator >
+            iterator_range( Iterator Begin, Iterator End ) :
+                m_Begin(Begin), m_End(End)
+            {}
+            template< class Range >
+            iterator_range( const Range& r ) :
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+            {}
+            template< class Range >
+            iterator_range( Range& r ) :
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+            {}
+            template< class Range >
+            iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+            {}
+            template< class Range >
+            iterator_range( Range& r, iterator_range_detail::range_tag ) :
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+            {}
+            this_type& operator=( const this_type& r )
+            {
+                m_Begin = r.begin();
+                m_End = r.end();
+                return *this;
+            }
+            template< class Iterator >
+            iterator_range& operator=( const iterator_range<Iterator>& r )
+            {
+                m_Begin = r.begin();
+                m_End = r.end();
+                return *this;
+            }
+            template< class ForwardRange >
+            iterator_range& operator=( ForwardRange& r )
+            {
+                m_Begin = impl::adl_begin( r );
+                m_End = impl::adl_end( r );
+                return *this;
+            }
+            template< class ForwardRange >
+            iterator_range& operator=( const ForwardRange& r )
+            {
+                m_Begin = impl::adl_begin( r );
+                m_End = impl::adl_end( r );
+                return *this;
+            }
+            IteratorT begin() const
+            {
+                return m_Begin;
+            }
+            IteratorT end() const
+            {
+                return m_End;
+            }
+            difference_type size() const
+            {
+                return m_End - m_Begin;
+            }
+            bool empty() const
+            {
+                return m_Begin == m_End;
+            }
+            operator unspecified_bool_type() const
+            {
+                return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin);
+            }
+            bool operator!() const
+            {
+                return empty();
+            }
+            bool equal( const iterator_range& r ) const
+            {
+                return m_Begin == r.m_Begin && m_End == r.m_End;
+            }
+        public:
+           reference front() const
+           {
+               (static_cast<void> (0));
+               return *m_Begin;
+           }
+           reference back() const
+           {
+               (static_cast<void> (0));
+               IteratorT last( m_End );
+               return *--last;
+           }
+           void pop_front()
+           {
+               (static_cast<void> (0));
+               ++m_Begin;
+           }
+           void pop_back()
+           {
+               (static_cast<void> (0));
+               --m_End;
+           }
+           reference operator[]( difference_type at ) const
+           {
+               (static_cast<void> (0));
+               return m_Begin[at];
+           }
+           abstract_value_type operator()( difference_type at ) const
+           {
+               (static_cast<void> (0));
+               return m_Begin[at];
+           }
+           iterator_range& advance_begin( difference_type n )
+           {
+               std::advance( m_Begin, n );
+               return *this;
+           }
+           iterator_range& advance_end( difference_type n )
+           {
+               std::advance( m_End, n );
+               return *this;
+           }
+        private:
+            IteratorT m_Begin;
+            IteratorT m_End;
+        protected:
+            typedef iterator_range iterator_range_;
+        };
+        template< class IteratorT, class ForwardRange >
+        inline bool operator==( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return boost::equal( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator!=( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return !boost::equal( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<( const ForwardRange& l,
+                               const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::less_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<=( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>( const ForwardRange& l,
+                               const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>=( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator==( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return boost::equal( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator==( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return boost::equal( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator!=( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return !boost::equal( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator!=( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return !boost::equal( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator<( const iterator_range<Iterator1T>& l,
+                               const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::less_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<( const iterator_range<IteratorT>& l,
+                               const ForwardRange& r )
+        {
+            return iterator_range_detail::less_than( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator<=( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<=( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator>( const iterator_range<Iterator1T>& l,
+                               const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>( const iterator_range<IteratorT>& l,
+                               const ForwardRange& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator>=( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>=( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
+        template< typename IteratorT >
+        inline iterator_range< IteratorT >
+        make_iterator_range( IteratorT Begin, IteratorT End )
+        {
+            return iterator_range<IteratorT>( Begin, End );
+        }
+        template< class ForwardRange >
+        inline iterator_range< typename range_iterator<ForwardRange>::type >
+        make_iterator_range( ForwardRange& r )
+        {
+           return iterator_range< typename range_iterator<ForwardRange>::type >
+                ( r, iterator_range_detail::range_tag() );
+        }
+        template< class ForwardRange >
+        inline iterator_range< typename range_iterator<const ForwardRange>::type >
+        make_iterator_range( const ForwardRange& r )
+        {
+           return iterator_range< typename range_iterator<const ForwardRange>::type >
+                ( r, iterator_range_detail::const_range_tag() );
+        }
+        namespace iterator_range_detail
+        {
+            template< class Range >
+            inline iterator_range< typename range_iterator<Range>::type >
+            make_range_impl( Range& r,
+                             typename range_difference<Range>::type advance_begin,
+                             typename range_difference<Range>::type advance_end )
+            {
+                typename range_iterator<Range>::type
+                    new_begin = boost::begin( r ),
+                    new_end = boost::end( r );
+                std::advance( new_begin, advance_begin );
+                std::advance( new_end, advance_end );
+                return make_iterator_range( new_begin, new_end );
+            }
+        }
+        template< class Range >
+        inline iterator_range< typename range_iterator<Range>::type >
+        make_iterator_range( Range& r,
+                    typename range_difference<Range>::type advance_begin,
+                    typename range_difference<Range>::type advance_end )
+        {
+            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+        }
+        template< class Range >
+        inline iterator_range< typename range_iterator<const Range>::type >
+        make_iterator_range( const Range& r,
+                    typename range_difference<Range>::type advance_begin,
+                    typename range_difference<Range>::type advance_end )
+        {
+            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+        }
+        template< typename SeqT, typename Range >
+        inline SeqT copy_range( const Range& r )
+        {
+            return SeqT( boost::begin( r ), boost::end( r ) );
+        }
+}
+namespace boost
+{
+        template< typename IteratorT, typename Elem, typename Traits >
+        inline std::basic_ostream<Elem,Traits>& operator<<(
+                    std::basic_ostream<Elem, Traits>& Os,
+                    const iterator_range<IteratorT>& r )
+        {
+            std::copy( r.begin(), r.end(),
+                       std::ostream_iterator< typename
+                                              iterator_value<IteratorT>::type,
+                                              Elem, Traits>(Os) );
+            return Os;
+        }
+}
+namespace boost { namespace spirit { namespace traits
+{
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_value_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::value_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_iterator { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::iterator>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size_type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_reference { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::reference>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename T, typename Enable >
+    struct is_container
+      : mpl::bool_<
+            detail::has_value_type<T>::value &&
+            detail::has_iterator<T>::value &&
+            detail::has_size_type<T>::value &&
+            detail::has_reference<T>::value>
+    {};
+    template <typename T>
+    struct is_container<T&>
+      : is_container<T>
+    {};
+    template <typename T>
+    struct is_container<boost::optional<T> >
+      : is_container<T>
+    {};
+    template <>
+    struct is_container<boost::detail::variant::void_>
+      : mpl::false_
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct is_container<variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> >
+       : mpl::bool_<
+ is_container<T0>::value || is_container<T1>::value || is_container<T2>::value || is_container<T3>::value || is_container<T4>::value || is_container<T5>::value || is_container<T6>::value || is_container<T7>::value || is_container<T8>::value || is_container<T9>::value || is_container<T10>::value || is_container<T11>::value || is_container<T12>::value || is_container<T13>::value || is_container<T14>::value || is_container<T15>::value || is_container<T16>::value || is_container<T17>::value || is_container<T18>::value || is_container<T19>::value || false>
+    {};
+    template <typename T, typename Enable >
+    struct is_iterator_range
+      : mpl::false_
+    {};
+    template <typename T>
+    struct is_iterator_range<iterator_range<T> >
+      : mpl::true_
+    {};
+    namespace detail
+    {
+        template <typename T>
+        struct remove_value_const
+        {
+            typedef T type;
+        };
+        template <typename T>
+        struct remove_value_const<T const>
+          : remove_value_const<T>
+        {};
+        template <typename F, typename S>
+        struct remove_value_const<std::pair<F, S> >
+        {
+            typedef typename remove_value_const<F>::type first_type;
+            typedef typename remove_value_const<S>::type second_type;
+            typedef std::pair<first_type, second_type> type;
+        };
+    }
+    template <typename Container, typename Enable >
+    struct container_value
+      : detail::remove_value_const<typename Container::value_type>
+    {};
+    template <typename T>
+    struct container_value<T&>
+      : container_value<T>
+    {};
+    template <typename T>
+    struct container_value<boost::optional<T> >
+      : container_value<T>
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct container_value<variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> >
+    {
+        typedef typename
+            variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>::types
+        types;
+        typedef typename
+            mpl::find_if<types, is_container<mpl::_1> >::type
+        iter;
+        typedef typename container_value<
+            typename mpl::if_<
+                is_same<iter, typename mpl::end<types>::type>
+              , unused_type, typename mpl::deref<iter>::type
+            >::type
+        >::type type;
+    };
+    template <>
+    struct container_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+    template <>
+    struct container_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+    template <typename Container, typename Enable >
+    struct container_iterator
+    {
+        typedef typename Container::iterator type;
+    };
+    template <typename Container>
+    struct container_iterator<Container&>
+      : container_iterator<Container>
+    {};
+    template <typename Container>
+    struct container_iterator<Container const>
+    {
+        typedef typename Container::const_iterator type;
+    };
+    template <typename T>
+    struct container_iterator<optional<T> >
+      : container_iterator<T>
+    {};
+    template <typename T>
+    struct container_iterator<optional<T> const>
+      : container_iterator<T const>
+    {};
+    template <typename Iterator>
+    struct container_iterator<iterator_range<Iterator> >
+    {
+        typedef typename range_const_iterator<
+              iterator_range<Iterator> >::type type;
+    };
+    template <>
+    struct container_iterator<unused_type>
+    {
+        typedef unused_type const* type;
+    };
+    template <>
+    struct container_iterator<unused_type const>
+    {
+        typedef unused_type const* type;
+    };
+    template <typename T, typename Enable >
+    struct optional_attribute
+    {
+        typedef T const& type;
+        static type call(T const& val)
+        {
+            return val;
+        }
+        static bool is_valid(T const&)
+        {
+            return true;
+        }
+    };
+    template <typename T>
+    struct optional_attribute<boost::optional<T> >
+    {
+        typedef T const& type;
+        static type call(boost::optional<T> const& val)
+        {
+            return boost::get<T>(val);
+        }
+        static bool is_valid(boost::optional<T> const& val)
+        {
+            return val;
+        }
+    };
+    template <typename T>
+    typename optional_attribute<T>::type
+    optional_value(T const& val)
+    {
+        return optional_attribute<T>::call(val);
+    }
+    inline unused_type optional_value(unused_type)
+    {
+        return unused;
+    }
+    template <typename T>
+    bool has_optional_value(T const& val)
+    {
+        return optional_attribute<T>::is_valid(val);
+    }
+    inline bool has_optional_value(unused_type)
+    {
+        return true;
+    }
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val);
+    template <typename Container, typename T, typename Enable >
+    struct push_back_container
+    {
+        static bool call(Container& c, T const& val)
+        {
+            c.insert(c.end(), val);
+            return true;
+        }
+    };
+    template <typename Container, typename T>
+    struct push_back_container<optional<Container>, T>
+    {
+        static bool call(boost::optional<Container>& c, T const& val)
+        {
+            if (!c)
+                c = Container();
+            return push_back(boost::get<Container>(c), val);
+        }
+    };
+    namespace detail
+    {
+        template <typename T>
+        struct push_back_visitor : public static_visitor<>
+        {
+            typedef bool result_type;
+            push_back_visitor(T const& t) : t_(t) {}
+            template <typename Container>
+            bool push_back_impl(Container& c, mpl::true_) const
+            {
+                return push_back(c, t_);
+            }
+            template <typename T_>
+            bool push_back_impl(T_&, mpl::false_) const
+            {
+                (static_cast<void> (0));
+                return false;
+            }
+            template <typename T_>
+            bool operator()(T_& c) const
+            {
+                return push_back_impl(c, typename is_container<T_>::type());
+            }
+            T const& t_;
+        };
+    }
+    template < typename T_0 , typename T_1 , typename T_2 , typename T_3 , typename T_4 , typename T_5 , typename T_6 , typename T_7 , typename T_8 , typename T_9 , typename T_10 , typename T_11 , typename T_12 , typename T_13 , typename T_14 , typename T_15 , typename T_16 , typename T_17 , typename T_18 , typename T_19, typename T>
+    struct push_back_container<variant< T_0 , T_1 , T_2 , T_3 , T_4 , T_5 , T_6 , T_7 , T_8 , T_9 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19>, T>
+    {
+        static bool call(variant< T_0 , T_1 , T_2 , T_3 , T_4 , T_5 , T_6 , T_7 , T_8 , T_9 , T_10 , T_11 , T_12 , T_13 , T_14 , T_15 , T_16 , T_17 , T_18 , T_19>& c, T const& val)
+        {
+            return apply_visitor(detail::push_back_visitor<T>(val), c);
+        }
+    };
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val)
+    {
+        return push_back_container<Container, T>::call(c, val);
+    }
+    template <typename Container>
+    bool push_back(Container&, unused_type)
+    {
+        return true;
+    }
+    template <typename T>
+    bool push_back(unused_type, T const&)
+    {
+        return true;
+    }
+    inline bool push_back(unused_type, unused_type)
+    {
+        return true;
+    }
+    template <typename Container, typename Enable >
+    struct is_empty_container
+    {
+        static bool call(Container const& c)
+        {
+            return c.empty();
+        }
+    };
+    template <typename Container>
+    bool is_empty(Container const& c)
+    {
+        return is_empty_container<Container>::call(c);
+    }
+    inline bool is_empty(unused_type)
+    {
+        return true;
+    }
+    template <typename Container, typename Enable >
+    struct make_container_attribute
+    {
+        static void call(Container&)
+        {
+        }
+    };
+    template <typename T>
+    void make_container(T& t)
+    {
+        make_container_attribute<T>::call(t);
+    }
+    inline void make_container(unused_type)
+    {
+    }
+    template <typename Container, typename Enable >
+    struct begin_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.begin();
+        }
+    };
+    template <typename Container>
+    typename spirit::result_of::begin<Container>::type
+    begin(Container& c)
+    {
+        return begin_container<Container>::call(c);
+    }
+    inline unused_type const*
+    begin(unused_type)
+    {
+        return &unused;
+    }
+    template <typename Container, typename Enable >
+    struct end_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.end();
+        }
+    };
+    template <typename Container>
+    inline typename spirit::result_of::end<Container>::type
+    end(Container& c)
+    {
+        return end_container<Container>::call(c);
+    }
+    inline unused_type const*
+    end(unused_type)
+    {
+        return &unused;
+    }
+    template <typename Iterator, typename Enable >
+    struct deref_iterator
+    {
+        typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+        static type call(Iterator& it)
+        {
+            return *it;
+        }
+    };
+    template <typename Iterator>
+    typename deref_iterator<Iterator>::type
+    deref(Iterator& it)
+    {
+        return deref_iterator<Iterator>::call(it);
+    }
+    inline unused_type
+    deref(unused_type const*)
+    {
+        return unused;
+    }
+    template <typename Iterator, typename Enable >
+    struct next_iterator
+    {
+        static void call(Iterator& it)
+        {
+            ++it;
+        }
+    };
+    template <typename Iterator>
+    void next(Iterator& it)
+    {
+        next_iterator<Iterator>::call(it);
+    }
+    inline void next(unused_type const*)
+    {
+    }
+    template <typename Iterator, typename Enable >
+    struct compare_iterators
+    {
+        static bool call(Iterator const& it1, Iterator const& it2)
+        {
+            return it1 == it2;
+        }
+    };
+    template <typename Iterator>
+    bool compare(Iterator& it1, Iterator& it2)
+    {
+        return compare_iterators<Iterator>::call(it1, it2);
+    }
+    inline bool compare(unused_type const*, unused_type const*)
+    {
+        return false;
+    }
+}}}
+namespace boost { namespace spirit { namespace result_of
+{
+    template <typename T>
+    struct optional_value
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct optional_value<boost::optional<T> >
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct optional_value<boost::optional<T> const>
+    {
+        typedef T const type;
+    };
+    template <>
+    struct optional_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+    template <>
+    struct optional_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+    template <typename Container>
+    struct begin
+      : traits::container_iterator<Container>
+    {};
+    template <typename Container>
+    struct end
+      : traits::container_iterator<Container>
+    {};
+    template <typename Iterator>
+    struct deref
+      : traits::deref_iterator<Iterator>
+    {};
+    template <>
+    struct deref<unused_type const*>
+    {
+        typedef unused_type type;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T>
+    struct is_char : mpl::false_ {};
+    template <typename T>
+    struct is_char<T const> : is_char<T> {};
+    template <>
+    struct is_char<char> : mpl::true_ {};
+    template <>
+    struct is_char<wchar_t> : mpl::true_ {};
+    template <typename T>
+    struct is_string : mpl::false_ {};
+    template <typename T>
+    struct is_string<T const> : is_string<T> {};
+    template <>
+    struct is_string<char const*> : mpl::true_ {};
+    template <>
+    struct is_string<wchar_t const*> : mpl::true_ {};
+    template <>
+    struct is_string<char*> : mpl::true_ {};
+    template <>
+    struct is_string<wchar_t*> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<char[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<wchar_t[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<char const[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<wchar_t const[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<char(&)[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<wchar_t(&)[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<char const(&)[N]> : mpl::true_ {};
+    template <std::size_t N>
+    struct is_string<wchar_t const(&)[N]> : mpl::true_ {};
+    template <typename T, typename Traits, typename Allocator>
+    struct is_string<std::basic_string<T, Traits, Allocator> > : mpl::true_ {};
+    template <typename T>
+    struct char_type_of;
+    template <typename T>
+    struct char_type_of<T const> : char_type_of<T> {};
+    template <>
+    struct char_type_of<char> : mpl::identity<char> {};
+    template <>
+    struct char_type_of<wchar_t> : mpl::identity<wchar_t> {};
+    template <>
+    struct char_type_of<char const*> : mpl::identity<char const> {};
+    template <>
+    struct char_type_of<wchar_t const*> : mpl::identity<wchar_t const> {};
+    template <>
+    struct char_type_of<char*> : mpl::identity<char> {};
+    template <>
+    struct char_type_of<wchar_t*> : mpl::identity<wchar_t> {};
+    template <std::size_t N>
+    struct char_type_of<char[N]> : mpl::identity<char> {};
+    template <std::size_t N>
+    struct char_type_of<wchar_t[N]> : mpl::identity<wchar_t> {};
+    template <std::size_t N>
+    struct char_type_of<char const[N]> : mpl::identity<char const> {};
+    template <std::size_t N>
+    struct char_type_of<wchar_t const[N]> : mpl::identity<wchar_t const> {};
+    template <std::size_t N>
+    struct char_type_of<char(&)[N]> : mpl::identity<char> {};
+    template <std::size_t N>
+    struct char_type_of<wchar_t(&)[N]> : mpl::identity<wchar_t> {};
+    template <std::size_t N>
+    struct char_type_of<char const(&)[N]> : mpl::identity<char const> {};
+    template <std::size_t N>
+    struct char_type_of<wchar_t const(&)[N]> : mpl::identity<wchar_t const> {};
+    template <typename T, typename Traits, typename Allocator>
+    struct char_type_of<std::basic_string<T, Traits, Allocator> >
+      : mpl::identity<T> {};
+    template <typename String>
+    struct extract_c_string;
+    template <typename String>
+    struct extract_c_string
+    {
+        typedef typename char_type_of<String>::type char_type;
+        template <typename T>
+        static T const* call (T* str)
+        {
+            return (T const*)str;
+        }
+        template <typename T>
+        static T const* call (T const* str)
+        {
+            return str;
+        }
+    };
+    template <typename T>
+    struct extract_c_string<T const>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+        static typename extract_c_string<T>::char_type const* call (T const str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+    template <typename T>
+    struct extract_c_string<T&>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+        static typename extract_c_string<T>::char_type const* call (T& str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+    template <typename T>
+    struct extract_c_string<T const&>
+    {
+        typedef typename extract_c_string<T>::char_type char_type;
+        static typename extract_c_string<T>::char_type const* call (T const& str)
+        {
+            return extract_c_string<T>::call(str);
+        }
+    };
+    template <typename T, typename Traits, typename Allocator>
+    struct extract_c_string<std::basic_string<T, Traits, Allocator> >
+    {
+        typedef T char_type;
+        typedef std::basic_string<T, Traits, Allocator> string;
+        static T const* call (string const& str)
+        {
+            return str.c_str();
+        }
+    };
+    template <typename T>
+    typename extract_c_string<T*>::char_type const*
+    get_c_string (T* str)
+    {
+        return extract_c_string<T*>::call(str);
+    }
+    template <typename T>
+    typename extract_c_string<T const*>::char_type const*
+    get_c_string (T const* str)
+    {
+        return extract_c_string<T const*>::call(str);
+    }
+    template <typename String>
+    typename extract_c_string<String>::char_type const*
+    get_c_string (String& str)
+    {
+        return extract_c_string<String>::call(str);
+    }
+    template <typename String>
+    typename extract_c_string<String>::char_type const*
+    get_c_string (String const& str)
+    {
+        return extract_c_string<String>::call(str);
+    }
+    template <typename T>
+    inline T const* get_begin(T const* str) { return str; }
+    template <typename T>
+    inline T* get_begin(T* str) { return str; }
+    template <typename T>
+    inline T const* get_end(T const* str)
+    {
+        T const* last = str;
+        while (*last)
+            last++;
+        return last;
+    }
+    template <typename T>
+    inline T* get_end(T* str)
+    {
+        T* last = str;
+        while (*last)
+            last++;
+        return last;
+    }
+    template <typename T, typename Str>
+    inline typename Str::const_iterator get_begin(Str const& str)
+    { return str.begin(); }
+    template <typename T, typename Str>
+    inline typename Str::iterator
+    get_begin(Str& str )
+    { return str.begin(); }
+    template <typename T, typename Str>
+    inline typename Str::const_iterator get_end(Str const& str)
+    { return str.end(); }
+    template <typename T, typename Str>
+    inline typename Str::iterator
+    get_end(Str& str )
+    { return str.end(); }
+    template <typename T, typename Str>
+    inline typename disable_if<is_container<Str>
+      , T const*>::type get_begin(Str const& str)
+    { return str; }
+    template <typename T, typename Str>
+    inline typename disable_if<is_container<Str>
+      , T const*>::type get_end(Str const& str)
+    { return get_end(get_begin<T>(str)); }
+}
+namespace result_of
+{
+    template <typename Char, typename T, typename Enable = void>
+    struct get_begin
+    {
+        typedef typename traits::char_type_of<T>::type char_type;
+        typedef typename mpl::if_<
+            is_const<char_type>
+          , char_type const
+          , char_type
+        >::type* type;
+    };
+    template <typename Char, typename Str>
+    struct get_begin<Char, Str
+      , typename enable_if<traits::is_container<Str> >::type>
+    {
+        typedef typename mpl::if_<
+            is_const<Str>
+          , typename Str::const_iterator
+          , typename Str::iterator
+        >::type type;
+    };
+    template <typename Char, typename T>
+    struct get_end : get_begin<Char, T> {};
+}
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Context>
+    struct expand_arg
+    {
+        template <typename T>
+        struct result_type
+        {
+            typedef typename
+                mpl::eval_if<
+                    mpl::or_<is_scalar<T>, traits::is_string<T> >
+                  , mpl::identity<T const &>
+                  , boost::result_of<T(unused_type, Context)>
+                >::type
+            type;
+        };
+        template <typename T>
+        struct result;
+        template <typename F, typename A0>
+        struct result<F(A0)>
+          : result_type<A0> {};
+        template <typename F, typename A0>
+        struct result<F(A0&)>
+          : result_type<A0> {};
+        expand_arg(Context& context)
+          : context(context)
+        {
+        }
+        template <typename T>
+        typename result_type<T>::type
+        call(T const& f, mpl::false_) const
+        {
+            return f(unused, context);
+        }
+        template <typename T>
+        typename result_type<T>::type
+        call(T const& val, mpl::true_) const
+        {
+            return val;
+        }
+        template <typename T>
+        typename result_type<T>::type
+        operator()(T const& x) const
+        {
+            return call(x, mpl::or_<is_scalar<T>, traits::is_string<T> >());
+        }
+        Context& context;
+    private:
+        expand_arg& operator= (expand_arg const&);
+    };
+}}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <
+        typename First
+      , typename Last
+      , bool is_empty = result_of::equal_to<First, Last>::value>
+    struct build_cons;
+    template <typename First, typename Last>
+    struct build_cons<First, Last, true>
+    {
+        typedef nil type;
+        static nil
+        call(First const&, Last const&)
+        {
+            return nil();
+        }
+    };
+    template <typename First, typename Last>
+    struct build_cons<First, Last, false>
+    {
+        typedef
+            build_cons<typename result_of::next<First>::type, Last>
+        next_build_cons;
+        typedef cons<
+            typename result_of::value_of<First>::type
+          , typename next_build_cons::type>
+        type;
+        static type
+        call(First const& f, Last const& l)
+        {
+            typename result_of::value_of<First>::type v = *f;
+            return type(v, next_build_cons::call(fusion::next(f), l));
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct cons_tag;
+    namespace extension
+    {
+        template <typename T>
+        struct convert_impl;
+        template <>
+        struct convert_impl<cons_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename
+                    detail::build_cons<
+                        typename result_of::begin<Sequence>::type
+                      , typename result_of::end<Sequence>::type
+                    >
+                build_cons;
+                typedef typename build_cons::type type;
+                static type
+                call(Sequence& seq)
+                {
+                    return build_cons::call(fusion::begin(seq), fusion::end(seq));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct as_list
+        {
+            typedef typename
+                detail::build_cons<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type
+                >
+            build_cons;
+            typedef typename build_cons::type type;
+            static type
+            call(Sequence& seq)
+            {
+                return build_cons::call(fusion::begin(seq), fusion::end(seq));
+            }
+        };
+    }
+    template <typename Sequence>
+    inline typename result_of::as_list<Sequence>::type
+    as_list(Sequence& seq)
+    {
+        return result_of::as_list<Sequence>::call(seq);
+    }
+    template <typename Sequence>
+    inline typename result_of::as_list<Sequence const>::type
+    as_list(Sequence const& seq)
+    {
+        return result_of::as_list<Sequence const>::call(seq);
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template <typename Sequence1, typename Sequence2, typename F = void_>
+        struct transform
+        {
+            typedef transform_view<Sequence1, Sequence2, F> type;
+        };
+        template <typename Sequence, typename F>
+        struct transform<Sequence, F>
+        {
+            typedef transform_view<Sequence, F> type;
+        };
+    }
+    template <typename Sequence, typename F>
+    inline typename result_of::transform<Sequence const, F>::type
+    transform(Sequence const& seq, F f)
+    {
+        return transform_view<Sequence const, F>(seq, f);
+    }
+    template <typename Sequence1, typename Sequence2, typename F>
+    inline typename result_of::transform<Sequence1 const, Sequence2 const, F>::type
+    transform(Sequence1 const& seq1, Sequence2 const& seq2, F f)
+    {
+        return transform_view<Sequence1 const, Sequence2 const, F>(seq1, seq2, f);
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <int>
+    struct attribute;
+    template <int>
+    struct local_variable;
+}}
+namespace boost { namespace spirit
+{
+    template <typename Attributes, typename Locals>
+    struct context
+    {
+        typedef Attributes attributes_type;
+        typedef Locals locals_type;
+        context(typename Attributes::car_type attribute)
+          : attributes(attribute, fusion::nil()), locals() {}
+        template <typename Args, typename Context>
+        context(
+            typename Attributes::car_type attribute
+          , Args const& args
+          , Context& caller_context
+        ) : attributes(
+                attribute
+              , fusion::as_list(
+                    fusion::transform(
+                        args
+                      , detail::expand_arg<Context>(caller_context)
+                    )
+                )
+            )
+          , locals() {}
+        context(Attributes const& attributes)
+          : attributes(attributes), locals() {}
+        Attributes attributes;
+        Locals locals;
+    };
+    template <typename Context>
+    struct attributes_of
+    {
+        typedef typename Context::attributes_type type;
+    };
+    template <typename Context>
+    struct attributes_of<Context const>
+    {
+        typedef typename Context::attributes_type const type;
+    };
+    template <typename Context>
+    struct attributes_of<Context &>
+      : attributes_of<Context>
+    {};
+    template <typename Context>
+    struct locals_of
+    {
+        typedef typename Context::locals_type type;
+    };
+    template <typename Context>
+    struct locals_of<Context const>
+    {
+        typedef typename Context::locals_type const type;
+    };
+    template <typename Context>
+    struct locals_of<Context &>
+    {
+        typedef typename Context::locals_type type;
+    };
+    template <int N>
+    struct attribute
+    {
+        typedef mpl::true_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                attributes_of<typename
+                    mpl::at_c<typename Env::args_type, 1>::type
+                >::type
+            attributes_type;
+            typedef typename
+                fusion::result_of::size<attributes_type>::type
+            attributes_size;
+            struct index_is_out_of_bounds; typedef struct
+ index_is_out_of_bounds182
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (index_is_out_of_bounds::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg182
+            ; enum { mpl_assertion_in_line_182 = sizeof( boost::mpl::assertion_failed<((N < attributes_size::value))>( mpl_assert_arg182::assert_arg() ) ) }
+                                           ;
+            typedef typename
+                fusion::result_of::at_c<attributes_type, N>::type
+            type;
+        };
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return fusion::at_c<N>((fusion::at_c<1>(env.args())).attributes);
+        }
+    };
+    template <int N>
+    struct local_variable
+    {
+        typedef mpl::true_ no_nullary;
+        template <typename Env>
+        struct result
+        {
+            typedef typename
+                locals_of<typename
+                    mpl::at_c<typename Env::args_type, 1>::type
+                >::type
+            locals_type;
+            typedef typename
+                fusion::result_of::size<locals_type>::type
+            locals_size;
+            struct index_is_out_of_bounds; typedef struct
+ index_is_out_of_bounds218
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (index_is_out_of_bounds::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg218
+            ; enum { mpl_assertion_in_line_218 = sizeof( boost::mpl::assertion_failed<((N < locals_size::value))>( mpl_assert_arg218::assert_arg() ) ) }
+                                           ;
+            typedef typename
+                fusion::result_of::at_c<locals_type, N>::type
+            type;
+        };
+        template <typename Env>
+        typename result<Env>::type
+        eval(Env const& env) const
+        {
+            return get_arg<N>((fusion::at_c<1>(env.args())).locals);
+        }
+    };
+    typedef phoenix::actor<attribute<0> > _val_type;
+    typedef phoenix::actor<attribute<0> > _r0_type;
+    typedef phoenix::actor<attribute<1> > _r1_type;
+    typedef phoenix::actor<attribute<2> > _r2_type;
+    _val_type const _val = _val_type();
+    _r0_type const _r0 = _r0_type();
+    _r1_type const _r1 = _r1_type();
+    _r2_type const _r2 = _r2_type();
+ typedef phoenix::actor<attribute<3> > _r3_type; phoenix::actor<attribute<3> > const _r3 = _r3_type(); typedef phoenix::actor<attribute<4> > _r4_type; phoenix::actor<attribute<4> > const _r4 = _r4_type(); typedef phoenix::actor<attribute<5> > _r5_type; phoenix::actor<attribute<5> > const _r5 = _r5_type(); typedef phoenix::actor<attribute<6> > _r6_type; phoenix::actor<attribute<6> > const _r6 = _r6_type(); typedef phoenix::actor<attribute<7> > _r7_type; phoenix::actor<attribute<7> > const _r7 = _r7_type(); typedef phoenix::actor<attribute<8> > _r8_type; phoenix::actor<attribute<8> > const _r8 = _r8_type(); typedef phoenix::actor<attribute<9> > _r9_type; phoenix::actor<attribute<9> > const _r9 = _r9_type();
+    typedef phoenix::actor<local_variable<0> > _a_type;
+    typedef phoenix::actor<local_variable<1> > _b_type;
+    typedef phoenix::actor<local_variable<2> > _c_type;
+    typedef phoenix::actor<local_variable<3> > _d_type;
+    typedef phoenix::actor<local_variable<4> > _e_type;
+    typedef phoenix::actor<local_variable<5> > _f_type;
+    typedef phoenix::actor<local_variable<6> > _g_type;
+    typedef phoenix::actor<local_variable<7> > _h_type;
+    typedef phoenix::actor<local_variable<8> > _i_type;
+    typedef phoenix::actor<local_variable<9> > _j_type;
+    _a_type const _a = _a_type();
+    _b_type const _b = _b_type();
+    _c_type const _c = _c_type();
+    _d_type const _d = _d_type();
+    _e_type const _e = _e_type();
+    _f_type const _f = _f_type();
+    _g_type const _g = _g_type();
+    _h_type const _h = _h_type();
+    _i_type const _i = _i_type();
+    _j_type const _j = _j_type();
+    namespace labels
+    {
+        using spirit::_0_type; using spirit::_0; using spirit::_1_type; using spirit::_1; using spirit::_2_type; using spirit::_2; using spirit::_3_type; using spirit::_3; using spirit::_4_type; using spirit::_4; using spirit::_5_type; using spirit::_5; using spirit::_6_type; using spirit::_6; using spirit::_7_type; using spirit::_7; using spirit::_8_type; using spirit::_8; using spirit::_9_type; using spirit::_9;
+        using spirit::_r0_type; using spirit::_r0; using spirit::_r1_type; using spirit::_r1; using spirit::_r2_type; using spirit::_r2; using spirit::_r3_type; using spirit::_r3; using spirit::_r4_type; using spirit::_r4; using spirit::_r5_type; using spirit::_r5; using spirit::_r6_type; using spirit::_r6; using spirit::_r7_type; using spirit::_r7; using spirit::_r8_type; using spirit::_r8; using spirit::_r9_type; using spirit::_r9;
+        using spirit::_val;
+        using spirit::_a;
+        using spirit::_b;
+        using spirit::_c;
+        using spirit::_d;
+        using spirit::_e;
+        using spirit::_f;
+        using spirit::_g;
+        using spirit::_h;
+        using spirit::_i;
+        using spirit::_j;
+    }
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    struct domain {};
+    using spirit::unused;
+    using spirit::unused_type;
+    using spirit::compile;
+    using spirit::info;
+    namespace labels
+    {
+        using spirit::_0_type; using spirit::_0; using spirit::_1_type; using spirit::_1; using spirit::_2_type; using spirit::_2; using spirit::_3_type; using spirit::_3; using spirit::_4_type; using spirit::_4; using spirit::_5_type; using spirit::_5; using spirit::_6_type; using spirit::_6; using spirit::_7_type; using spirit::_7; using spirit::_8_type; using spirit::_8; using spirit::_9_type; using spirit::_9;
+        using spirit::_r0_type; using spirit::_r0; using spirit::_r1_type; using spirit::_r1; using spirit::_r2_type; using spirit::_r2; using spirit::_r3_type; using spirit::_r3; using spirit::_r4_type; using spirit::_r4; using spirit::_r5_type; using spirit::_r5; using spirit::_r6_type; using spirit::_r6; using spirit::_r7_type; using spirit::_r7; using spirit::_r8_type; using spirit::_r8; using spirit::_r9_type; using spirit::_r9;
+        using spirit::_pass_type;
+        using spirit::_val_type;
+        using spirit::_a_type;
+        using spirit::_b_type;
+        using spirit::_c_type;
+        using spirit::_d_type;
+        using spirit::_e_type;
+        using spirit::_f_type;
+        using spirit::_g_type;
+        using spirit::_h_type;
+        using spirit::_i_type;
+        using spirit::_j_type;
+        using spirit::_pass;
+        using spirit::_val;
+        using spirit::_a;
+        using spirit::_b;
+        using spirit::_c;
+        using spirit::_d;
+        using spirit::_e;
+        using spirit::_f;
+        using spirit::_g;
+        using spirit::_h;
+        using spirit::_i;
+        using spirit::_j;
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Derived>
+    struct parser
+    {
+        struct parser_id;
+        typedef Derived derived_type;
+        typedef qi::domain domain;
+        Derived const& derived() const
+        {
+            return *static_cast<Derived const*>(this);
+        }
+    };
+    template <typename Derived>
+    struct primitive_parser : parser<Derived>
+    {
+        struct primitive_parser_id;
+    };
+    template <typename Derived>
+    struct nary_parser : parser<Derived>
+    {
+        struct nary_parser_id;
+    };
+    template <typename Derived>
+    struct unary_parser : parser<Derived>
+    {
+        struct unary_parser_id;
+    };
+    template <typename Derived>
+    struct binary_parser : parser<Derived>
+    {
+        struct binary_parser_id;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_primitive_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::primitive_parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_nary_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::nary_parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_unary_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::unary_parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_binary_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::binary_parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename T>
+    struct is_parser : detail::has_parser_id<T> {};
+    template <typename T>
+    struct is_primitive_parser : detail::has_primitive_parser_id<T> {};
+    template <typename T>
+    struct is_nary_parser : detail::has_nary_parser_id<T> {};
+    template <typename T>
+    struct is_unary_parser : detail::has_unary_parser_id<T> {};
+    template <typename T>
+    struct is_binary_parser : detail::has_binary_parser_id<T> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <typename T>
+    struct use_terminal<qi::domain, T
+      , typename enable_if<traits::is_parser<T> >::type>
+      : mpl::true_ {};
+    namespace qi
+    {
+        template <typename T, typename Modifiers, typename Enable = void>
+        struct make_primitive
+        {
+            typedef T result_type;
+            template <typename T_>
+            T_& operator()(T_& val, unused_type) const
+            {
+                return val;
+            }
+            template <typename T_>
+            T_ const& operator()(T_ const& val, unused_type) const
+            {
+                return val;
+            }
+        };
+        template <typename Tag, typename Elements
+          , typename Modifiers, typename Enable = void>
+        struct make_composite;
+        template <typename Directive, typename Body
+          , typename Modifiers, typename Enable = void>
+        struct make_directive
+        {
+            typedef Body result_type;
+            result_type operator()(unused_type, Body const& body, unused_type) const
+            {
+                return body;
+            }
+        };
+    }
+    template <>
+    struct make_component<qi::domain, proto::tag::terminal>
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename qi::make_primitive<
+                typename remove_const<typename Elements::car_type>::type,
+                typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            typedef typename remove_const<typename Elements::car_type>::type term;
+            return qi::make_primitive<term, Modifiers>()(elements.car, modifiers);
+        }
+    };
+    template <typename Tag>
+    struct make_component<qi::domain, Tag>
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_composite<Tag, Elements,
+                typename remove_reference<Modifiers>::type>::result_type
+            type;
+        };
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_composite<Tag, Elements, Modifiers>()(
+                elements, modifiers);
+        }
+    };
+    template <>
+    struct make_component<qi::domain, proto::tag::function>
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_composite<
+                    typename remove_const<typename Elements::car_type>::type,
+                    typename Elements::cdr_type,
+                    typename remove_reference<Modifiers>::type
+                >::result_type
+            type;
+        };
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_composite<
+                typename remove_const<typename Elements::car_type>::type,
+                typename Elements::cdr_type,
+                Modifiers>()(elements.cdr, modifiers);
+        }
+    };
+    template <>
+    struct make_component<qi::domain, tag::directive>
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                qi::make_directive<
+                    typename remove_const<typename Elements::car_type>::type,
+                    typename remove_const<typename Elements::cdr_type::car_type>::type,
+                    typename remove_reference<Modifiers>::type
+                >::result_type
+            type;
+        };
+        template <typename Elements, typename Modifiers>
+        typename result<make_component(Elements, Modifiers)>::type
+        operator()(Elements const& elements, Modifiers const& modifiers) const
+        {
+            return qi::make_directive<
+                typename remove_const<typename Elements::car_type>::type,
+                typename remove_const<typename Elements::cdr_type::car_type>::type,
+                Modifiers>()(elements.car, elements.cdr.car, modifiers);
+        }
+    };
+}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Enable = void>
+    struct has_semantic_action
+      : mpl::false_ {};
+    template <typename Subject>
+    struct unary_has_semantic_action
+      : has_semantic_action<Subject> {};
+    template <typename Left, typename Right>
+    struct binary_has_semantic_action
+      : mpl::or_<has_semantic_action<Left>, has_semantic_action<Right> > {};
+    template <typename Elements>
+    struct nary_has_semantic_action
+      : mpl::not_<
+            is_same<
+                typename mpl::find_if<
+                    Elements, has_semantic_action<mpl::_>
+                >::type
+              , typename mpl::end<Elements>::type
+            >
+        > {};
+}}}
+namespace boost { namespace spirit
+{
+    struct bad_any_cast
+      : std::bad_cast
+    {
+        bad_any_cast(boost::detail::sp_typeinfo const& src, boost::detail::sp_typeinfo const& dest)
+          : from(src.name()), to(dest.name())
+        {}
+        virtual const char* what() const throw() { return "bad any cast"; }
+        const char* from;
+        const char* to;
+    };
+    namespace detail
+    {
+        template <typename Char>
+        struct fxn_ptr_table
+        {
+            boost::detail::sp_typeinfo const& (*get_type)();
+            void (*static_delete)(void**);
+            void (*destruct)(void**);
+            void (*clone)(void* const*, void**);
+            void (*move)(void* const*, void**);
+            std::basic_istream<Char>& (*stream_in)(std::basic_istream<Char>&, void**);
+            std::basic_ostream<Char>& (*stream_out)(std::basic_ostream<Char>&, void* const*);
+        };
+        template <typename Small>
+        struct fxns;
+        template <>
+        struct fxns<mpl::true_>
+        {
+            template<typename T, typename Char>
+            struct type
+            {
+                static boost::detail::sp_typeinfo const& get_type()
+                {
+                    return typeid(T);
+                }
+                static void static_delete(void** x)
+                {
+                    reinterpret_cast<T*>(x)->~T();
+                }
+                static void destruct(void** x)
+                {
+                    reinterpret_cast<T*>(x)->~T();
+                }
+                static void clone(void* const* src, void** dest)
+                {
+                    new (dest) T(*reinterpret_cast<T const*>(src));
+                }
+                static void move(void* const* src, void** dest)
+                {
+                    reinterpret_cast<T*>(dest)->~T();
+                    *reinterpret_cast<T*>(dest) =
+                        *reinterpret_cast<T const*>(src);
+                }
+                static std::basic_istream<Char>&
+                stream_in (std::basic_istream<Char>& i, void** obj)
+                {
+                    i >> *reinterpret_cast<T*>(obj);
+                    return i;
+                }
+                static std::basic_ostream<Char>&
+                stream_out(std::basic_ostream<Char>& o, void* const* obj)
+                {
+                    o << *reinterpret_cast<T const*>(obj);
+                    return o;
+                }
+            };
+        };
+        template <>
+        struct fxns<mpl::false_>
+        {
+            template<typename T, typename Char>
+            struct type
+            {
+                static boost::detail::sp_typeinfo const& get_type()
+                {
+                    return typeid(T);
+                }
+                static void static_delete(void** x)
+                {
+                    delete (*reinterpret_cast<T**>(x));
+                }
+                static void destruct(void** x)
+                {
+                    (*reinterpret_cast<T**>(x))->~T();
+                }
+                static void clone(void* const* src, void** dest)
+                {
+                    *dest = new T(**reinterpret_cast<T* const*>(src));
+                }
+                static void move(void* const* src, void** dest)
+                {
+                    (*reinterpret_cast<T**>(dest))->~T();
+                    **reinterpret_cast<T**>(dest) =
+                        **reinterpret_cast<T* const*>(src);
+                }
+                static std::basic_istream<Char>&
+                stream_in(std::basic_istream<Char>& i, void** obj)
+                {
+                    i >> **reinterpret_cast<T**>(obj);
+                    return i;
+                }
+                static std::basic_ostream<Char>&
+                stream_out(std::basic_ostream<Char>& o, void* const* obj)
+                {
+                    o << **reinterpret_cast<T* const*>(obj);
+                    return o;
+                }
+            };
+        };
+        template <typename T>
+        struct get_table
+        {
+            typedef mpl::bool_<(sizeof(T) <= sizeof(void*))> is_small;
+            template <typename Char>
+            static fxn_ptr_table<Char>* get()
+            {
+                static fxn_ptr_table<Char> static_table =
+                {
+                    fxns<is_small>::template type<T, Char>::get_type,
+                    fxns<is_small>::template type<T, Char>::static_delete,
+                    fxns<is_small>::template type<T, Char>::destruct,
+                    fxns<is_small>::template type<T, Char>::clone,
+                    fxns<is_small>::template type<T, Char>::move,
+                    fxns<is_small>::template type<T, Char>::stream_in,
+                    fxns<is_small>::template type<T, Char>::stream_out
+                };
+                return &static_table;
+            }
+        };
+        struct empty {};
+        template <typename Char>
+        inline std::basic_istream<Char>&
+        operator>> (std::basic_istream<Char>& i, empty&)
+        {
+            (static_cast<void> (0))
+                                    ;
+            return i;
+        }
+        template <typename Char>
+        inline std::basic_ostream<Char>&
+        operator<< (std::basic_ostream<Char>& o, empty const&)
+        {
+            return o;
+        }
+    }
+    template <typename Char>
+    class basic_hold_any
+    {
+    public:
+        template <typename T>
+        explicit basic_hold_any(T const& x)
+          : table(spirit::detail::get_table<T>::template get<Char>()), object(0)
+        {
+            if (spirit::detail::get_table<T>::is_small::value)
+                new (&object) T(x);
+            else
+                object = new T(x);
+        }
+        basic_hold_any()
+          : table(spirit::detail::get_table<spirit::detail::empty>::template get<Char>()),
+            object(0)
+        {
+        }
+        basic_hold_any(basic_hold_any const& x)
+          : table(spirit::detail::get_table<spirit::detail::empty>::template get<Char>()),
+            object(0)
+        {
+            assign(x);
+        }
+        ~basic_hold_any()
+        {
+            table->static_delete(&object);
+        }
+        basic_hold_any& assign(basic_hold_any const& x)
+        {
+            if (&x != this) {
+                if (table == x.table) {
+                    table->move(&x.object, &object);
+                }
+                else {
+                    reset();
+                    x.table->clone(&x.object, &object);
+                    table = x.table;
+                }
+            }
+            return *this;
+        }
+        template <typename T>
+        basic_hold_any& assign(T const& x)
+        {
+            spirit::detail::fxn_ptr_table<Char>* x_table =
+                spirit::detail::get_table<T>::template get<Char>();
+            if (table == x_table) {
+                table->destruct(&object);
+                if (spirit::detail::get_table<T>::is_small::value) {
+                    new (&object) T(x);
+                }
+                else {
+                    new (object) T(x);
+                }
+            }
+            else {
+                if (spirit::detail::get_table<T>::is_small::value) {
+                    table->destruct(&object);
+                    new (&object) T(x);
+                }
+                else {
+                    reset();
+                    object = new T(x);
+                }
+                table = x_table;
+            }
+            return *this;
+        }
+        template <typename T>
+        basic_hold_any& operator=(T const& x)
+        {
+            return assign(x);
+        }
+        basic_hold_any& swap(basic_hold_any& x)
+        {
+            std::swap(table, x.table);
+            std::swap(object, x.object);
+            return *this;
+        }
+        boost::detail::sp_typeinfo const& type() const
+        {
+            return table->get_type();
+        }
+        template <typename T>
+        T const& cast() const
+        {
+            if (type() != typeid(T))
+              throw bad_any_cast(type(), typeid(T));
+            return spirit::detail::get_table<T>::is_small::value ?
+                *reinterpret_cast<T const*>(&object) :
+                *reinterpret_cast<T const*>(object);
+        }
+        bool empty() const
+        {
+            return table == spirit::detail::get_table<spirit::detail::empty>::template get<Char>();
+        }
+        void reset()
+        {
+            if (!empty())
+            {
+                table->static_delete(&object);
+                table = spirit::detail::get_table<spirit::detail::empty>::template get<Char>();
+                object = 0;
+            }
+        }
+        template <typename Char_>
+        friend inline std::basic_istream<Char_>&
+        operator>> (std::basic_istream<Char_>& i, basic_hold_any<Char_>& obj)
+        {
+            return obj.table->stream_in(i, &obj.object);
+        }
+        template <typename Char_>
+        friend inline std::basic_ostream<Char_>&
+        operator<< (std::basic_ostream<Char_>& o, basic_hold_any<Char_> const& obj)
+        {
+            return obj.table->stream_out(o, &obj.object);
+        }
+    private:
+        template <typename T, typename Char_>
+        friend T* any_cast(basic_hold_any<Char_> *);
+        spirit::detail::fxn_ptr_table<Char>* table;
+        void* object;
+    };
+    template <typename T, typename Char>
+    inline T* any_cast (basic_hold_any<Char>* operand)
+    {
+        if (operand && operand->type() == typeid(T)) {
+            return spirit::detail::get_table<T>::is_small::value ?
+                reinterpret_cast<T*>(&operand->object) :
+                reinterpret_cast<T*>(operand->object);
+        }
+        return 0;
+    }
+    template <typename T, typename Char>
+    inline T const* any_cast(basic_hold_any<Char> const* operand)
+    {
+        return any_cast<T>(const_cast<basic_hold_any<Char>*>(operand));
+    }
+    template <typename T, typename Char>
+    T any_cast(basic_hold_any<Char>& operand)
+    {
+        typedef typename remove_reference<T>::type nonref;
+        nonref* result = any_cast<nonref>(&operand);
+        if(!result)
+            boost::throw_exception(bad_any_cast(operand.type(), typeid(T)));
+        return *result;
+    }
+    template <typename T, typename Char>
+    T const& any_cast(basic_hold_any<Char> const& operand)
+    {
+        typedef typename remove_reference<T>::type nonref;
+        return any_cast<nonref const&>(const_cast<basic_hold_any<Char> &>(operand));
+    }
+    typedef basic_hold_any<char> hold_any;
+    typedef basic_hold_any<wchar_t> whold_any;
+    namespace traits
+    {
+        template <typename T>
+        struct is_hold_any : mpl::false_ {};
+        template <typename Char>
+        struct is_hold_any<basic_hold_any<Char> > : mpl::true_ {};
+    }
+}}
+namespace boost { namespace mpl {
+template<
+      typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na
+    , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na
+    , typename T12 = na, typename T13 = na, typename T14 = na
+    , typename T15 = na, typename T16 = na, typename T17 = na
+    , typename T18 = na, typename T19 = na
+    >
+struct vector;
+template<
+    >
+struct vector<
+          na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector0< >
+{
+    typedef vector0< >::type type;
+};
+template<
+      typename T0
+    >
+struct vector<
+          T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector1<T0>
+{
+    typedef typename vector1<T0>::type type;
+};
+template<
+      typename T0, typename T1
+    >
+struct vector<
+          T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector2< T0,T1 >
+{
+    typedef typename vector2< T0,T1 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2
+    >
+struct vector<
+          T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector3< T0,T1,T2 >
+{
+    typedef typename vector3< T0,T1,T2 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct vector<
+          T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector4< T0,T1,T2,T3 >
+{
+    typedef typename vector4< T0,T1,T2,T3 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct vector<
+          T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector5< T0,T1,T2,T3,T4 >
+{
+    typedef typename vector5< T0,T1,T2,T3,T4 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector6< T0,T1,T2,T3,T4,T5 >
+{
+    typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector7< T0,T1,T2,T3,T4,T5,T6 >
+{
+    typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
+{
+    typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+{
+    typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+{
+    typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na
+        , na, na, na
+        >
+    : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+{
+    typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na
+        , na, na, na, na
+        >
+    : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+{
+    typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na
+        , na, na, na, na
+        >
+    : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+{
+    typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na
+        , na, na, na, na
+        >
+    : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+{
+    typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na
+        , na, na, na, na
+        >
+    : vector15<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        >
+{
+    typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, na, na, na, na
+        >
+    : vector16<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15
+        >
+{
+    typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, na, na, na
+        >
+    : vector17<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16
+        >
+{
+    typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, na, na
+        >
+    : vector18<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17
+        >
+{
+    typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct vector<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, na
+        >
+    : vector19<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18
+        >
+{
+    typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct vector
+    : vector20<
+          T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14
+        , T15, T16, T17, T18, T19
+        >
+{
+    typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type;
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename T = na
+    >
+struct find
+    : find_if< Sequence,same_as<T> >
+{
+};
+template<> struct find< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find< T1 , T2 > { }; }; template< typename Tag > struct lambda< find< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find< na , na > result_; typedef find< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template< typename Tag >
+struct contains_impl
+{
+    template< typename Sequence, typename T > struct apply
+        : not_< is_same<
+              typename find<Sequence,T>::type
+            , typename end<Sequence>::type
+            > >
+    {
+    };
+};
+ template<> struct contains_impl<non_sequence_tag> {};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Sequence = na
+    , typename T = na
+    >
+struct contains
+    : contains_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,T >
+{
+};
+template<> struct contains< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : contains< T1 , T2 > { }; }; template< typename Tag > struct lambda< contains< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef contains< na , na > result_; typedef contains< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< contains< T1 , T2 > > : int_<2> { }; template<> struct template_arity< contains< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <int size>
+    struct as_variant_impl;
+    template <>
+    struct as_variant_impl<0>
+    {
+        template <typename Iterator>
+        struct apply
+        {
+            typedef variant<> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<1>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1;
+            typedef typename fusion::result_of::value_of<I0>::type T0;
+            typedef variant< T0> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<2>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1;
+            typedef variant< T0 , T1> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<3>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2;
+            typedef variant< T0 , T1 , T2> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<4>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3;
+            typedef variant< T0 , T1 , T2 , T3> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<5>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4;
+            typedef variant< T0 , T1 , T2 , T3 , T4> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<6>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<7>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<8>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<9>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<10>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<11>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<12>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<13>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<14>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<15>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<16>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15; typedef typename fusion::result_of::next<I15>::type I16;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14; typedef typename fusion::result_of::value_of<I15>::type T15;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<17>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15; typedef typename fusion::result_of::next<I15>::type I16; typedef typename fusion::result_of::next<I16>::type I17;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14; typedef typename fusion::result_of::value_of<I15>::type T15; typedef typename fusion::result_of::value_of<I16>::type T16;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<18>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15; typedef typename fusion::result_of::next<I15>::type I16; typedef typename fusion::result_of::next<I16>::type I17; typedef typename fusion::result_of::next<I17>::type I18;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14; typedef typename fusion::result_of::value_of<I15>::type T15; typedef typename fusion::result_of::value_of<I16>::type T16; typedef typename fusion::result_of::value_of<I17>::type T17;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<19>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15; typedef typename fusion::result_of::next<I15>::type I16; typedef typename fusion::result_of::next<I16>::type I17; typedef typename fusion::result_of::next<I17>::type I18; typedef typename fusion::result_of::next<I18>::type I19;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14; typedef typename fusion::result_of::value_of<I15>::type T15; typedef typename fusion::result_of::value_of<I16>::type T16; typedef typename fusion::result_of::value_of<I17>::type T17; typedef typename fusion::result_of::value_of<I18>::type T18;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18> type;
+        };
+    };
+    template <>
+    struct as_variant_impl<20>
+    {
+        template <typename I0>
+        struct apply
+        {
+            typedef typename fusion::result_of::next<I0>::type I1; typedef typename fusion::result_of::next<I1>::type I2; typedef typename fusion::result_of::next<I2>::type I3; typedef typename fusion::result_of::next<I3>::type I4; typedef typename fusion::result_of::next<I4>::type I5; typedef typename fusion::result_of::next<I5>::type I6; typedef typename fusion::result_of::next<I6>::type I7; typedef typename fusion::result_of::next<I7>::type I8; typedef typename fusion::result_of::next<I8>::type I9; typedef typename fusion::result_of::next<I9>::type I10; typedef typename fusion::result_of::next<I10>::type I11; typedef typename fusion::result_of::next<I11>::type I12; typedef typename fusion::result_of::next<I12>::type I13; typedef typename fusion::result_of::next<I13>::type I14; typedef typename fusion::result_of::next<I14>::type I15; typedef typename fusion::result_of::next<I15>::type I16; typedef typename fusion::result_of::next<I16>::type I17; typedef typename fusion::result_of::next<I17>::type I18; typedef typename fusion::result_of::next<I18>::type I19; typedef typename fusion::result_of::next<I19>::type I20;
+            typedef typename fusion::result_of::value_of<I0>::type T0; typedef typename fusion::result_of::value_of<I1>::type T1; typedef typename fusion::result_of::value_of<I2>::type T2; typedef typename fusion::result_of::value_of<I3>::type T3; typedef typename fusion::result_of::value_of<I4>::type T4; typedef typename fusion::result_of::value_of<I5>::type T5; typedef typename fusion::result_of::value_of<I6>::type T6; typedef typename fusion::result_of::value_of<I7>::type T7; typedef typename fusion::result_of::value_of<I8>::type T8; typedef typename fusion::result_of::value_of<I9>::type T9; typedef typename fusion::result_of::value_of<I10>::type T10; typedef typename fusion::result_of::value_of<I11>::type T11; typedef typename fusion::result_of::value_of<I12>::type T12; typedef typename fusion::result_of::value_of<I13>::type T13; typedef typename fusion::result_of::value_of<I14>::type T14; typedef typename fusion::result_of::value_of<I15>::type T15; typedef typename fusion::result_of::value_of<I16>::type T16; typedef typename fusion::result_of::value_of<I17>::type T17; typedef typename fusion::result_of::value_of<I18>::type T18; typedef typename fusion::result_of::value_of<I19>::type T19;
+            typedef variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> type;
+        };
+    };
+    template <typename Sequence>
+    struct as_variant
+    {
+        typedef typename
+            detail::as_variant_impl<fusion::result_of::size<Sequence>::value>
+        gen;
+        typedef typename gen::template apply<
+                typename fusion::result_of::begin<Sequence>::type
+            >::type
+        type;
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct filter_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct deref_impl;
+        template <>
+        struct deref_impl<filter_view_iterator_tag>
+            : detail::adapt_deref_traits {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_iterator_tag;
+    template <typename Category, typename First, typename Last, typename Pred>
+    struct filter_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct next_impl;
+        template <>
+        struct next_impl<filter_view_iterator_tag>
+        {
+            template <typename Iterator>
+            struct apply
+            {
+                typedef typename Iterator::first_type first_type;
+                typedef typename Iterator::last_type last_type;
+                typedef typename Iterator::pred_type pred_type;
+                typedef typename Iterator::category category;
+                typedef typename
+                    mpl::eval_if<
+                        result_of::equal_to<first_type, last_type>
+                      , mpl::identity<last_type>
+                      , result_of::next<first_type>
+                    >::type
+                next_type;
+                typedef typename
+                    detail::static_find_if<
+                        next_type
+                      , last_type
+                      , mpl::bind1<
+                            typename mpl::lambda<pred_type>::type
+                          , mpl::bind1<mpl::quote1<result_of::value_of>,mpl::_1>
+                        >
+                    >
+                filter;
+                typedef filter_iterator<
+                    category, typename filter::type, last_type, pred_type>
+                type;
+                static type
+                call(Iterator const& i)
+                {
+                    return type(filter::iter_call(i.first));
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_iterator_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct value_of_impl;
+        template <>
+        struct value_of_impl<filter_view_iterator_tag>
+            : detail::adapt_value_traits {};
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_iterator_tag;
+    namespace extension
+    {
+        template<typename I1, typename I2>
+        struct equal_to;
+        template<typename Tag>
+        struct equal_to_impl;
+        template<>
+        struct equal_to_impl<filter_view_iterator_tag>
+        {
+            template<typename I1, typename I2>
+            struct apply
+                : result_of::equal_to<typename I1::first_type, typename I2::first_type>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct deref_data_impl;
+    template <>
+    struct deref_data_impl<filter_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+        {
+            typedef typename
+                result_of::deref_data<typename It::first_type>::type
+            type;
+            static type
+            call(It const& it)
+            {
+                return fusion::deref_data(it.first);
+            }
+        };
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct value_of_data_impl;
+    template <>
+    struct value_of_data_impl<filter_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::value_of_data<typename It::first_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion { namespace extension
+{
+    template <typename>
+    struct key_of_impl;
+    template <>
+    struct key_of_impl<filter_view_iterator_tag>
+    {
+        template <typename It>
+        struct apply
+          : result_of::key_of<typename It::first_type>
+        {};
+    };
+}}}
+namespace boost { namespace fusion
+{
+    struct filter_view_iterator_tag;
+    struct forward_traversal_tag;
+    template <typename Category, typename First, typename Last, typename Pred>
+    struct filter_iterator : iterator_base<filter_iterator<Category, First, Last, Pred> >
+    {
+        typedef convert_iterator<First> first_converter;
+        typedef typename first_converter::type first_iter;
+        typedef convert_iterator<Last> last_converter;
+        typedef typename last_converter::type last_iter;
+        typedef filter_view_iterator_tag fusion_tag;
+        typedef Category category;
+        typedef
+            detail::static_find_if<
+                first_iter
+              , last_iter
+              , mpl::bind1<
+                    typename mpl::lambda<Pred>::type
+                  , mpl::bind1<mpl::quote1<result_of::value_of>,mpl::_1>
+                >
+            >
+        filter;
+        typedef typename filter::type first_type;
+        typedef last_iter last_type;
+        typedef Pred pred_type;
+        filter_iterator(First const& in_first)
+            : first(filter::iter_call(first_converter::call(in_first))) {}
+        first_type first;
+    private:
+        filter_iterator& operator= (filter_iterator const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_tag;
+    template <typename Category, typename First, typename Last, typename Pred>
+    struct filter_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct begin_impl;
+        template <>
+        struct begin_impl<filter_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::first_type first_type;
+                typedef typename Sequence::last_type last_type;
+                typedef typename Sequence::pred_type pred_type;
+                typedef typename Sequence::category category;
+                typedef filter_iterator<category, first_type, last_type, pred_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.first());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_tag;
+    template <typename Category, typename First, typename Last, typename Pred>
+    struct filter_iterator;
+    namespace extension
+    {
+        template <typename Tag>
+        struct end_impl;
+        template <>
+        struct end_impl<filter_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+            {
+                typedef typename Sequence::last_type last_type;
+                typedef typename Sequence::pred_type pred_type;
+                typedef typename Sequence::category category;
+                typedef filter_iterator<category,last_type, last_type, pred_type> type;
+                static type
+                call(Sequence& s)
+                {
+                    return type(s.last());
+                }
+            };
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_tag;
+    namespace extension
+    {
+        template <typename Tag>
+        struct size_impl;
+        template <>
+        struct size_impl<filter_view_tag>
+        {
+            template <typename Sequence>
+            struct apply
+                : result_of::distance<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>
+            {};
+        };
+    }
+}}
+namespace boost { namespace fusion
+{
+    struct filter_view_tag;
+    struct forward_traversal_tag;
+    struct fusion_sequence_tag;
+    template <typename Sequence, typename Pred>
+    struct filter_view : sequence_base<filter_view<Sequence, Pred> >
+    {
+        typedef filter_view_tag fusion_tag;
+        typedef fusion_sequence_tag tag;
+        typedef typename
+            mpl::eval_if<
+                traits::is_associative<Sequence>
+              , mpl::inherit2<forward_traversal_tag,associative_tag>
+              , mpl::identity<forward_traversal_tag>
+            >::type
+        category;
+        typedef mpl::true_ is_view;
+        typedef typename result_of::begin<Sequence>::type first_type;
+        typedef typename result_of::end<Sequence>::type last_type;
+        typedef Pred pred_type;
+        filter_view(Sequence& in_seq)
+            : seq(in_seq)
+        {}
+        first_type first() const { return fusion::begin(seq); }
+        last_type last() const { return fusion::end(seq); }
+        typename mpl::if_<traits::is_view<Sequence>, Sequence, Sequence&>::type seq;
+    private:
+        filter_view& operator= (filter_view const&);
+    };
+}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct filter_if
+        {
+            typedef filter_view<Sequence, Pred> type;
+        };
+    }
+    template <typename Pred, typename Sequence>
+    inline typename result_of::filter_if<Sequence const, Pred>::type
+    filter_if(Sequence const& seq)
+    {
+        return filter_view<Sequence const, Pred>(seq);
+    }
+}}
+namespace boost {
+template< typename T > struct add_cv { public: typedef T const volatile type; };
+template< typename T > struct add_cv<T&> { public: typedef T& type; };
+}
+namespace boost {
+namespace detail {
+template <typename T, bool is_const>
+struct remove_volatile_helper
+{
+    typedef T type;
+};
+template <typename T>
+struct remove_volatile_helper<T,true>
+{
+    typedef T const type;
+};
+template <typename T>
+struct remove_volatile_impl
+{
+    typedef typename remove_volatile_helper<
+          typename cv_traits_imp<T*>::unqualified_type
+        , ::boost::is_const<T>::value
+        >::type type;
+};
+}
+template< typename T > struct remove_volatile { public: typedef typename boost::detail::remove_volatile_impl<T>::type type; };
+template< typename T > struct remove_volatile<T&> { public: typedef T& type; };
+template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { public: typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { public: typedef T const type[N]; };
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+}
+namespace boost {
+template<class T>
+class initialized
+{
+  private :
+    struct wrapper
+    {
+      typename
+      remove_const<T>::type data;
+      wrapper()
+      :
+      data()
+      {
+      }
+      wrapper(T const & arg)
+      :
+      data(arg)
+      {
+      }
+    };
+    mutable
+      typename
+      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
+    wrapper * wrapper_address() const
+    {
+      return static_cast<wrapper *>( static_cast<void*>(&x));
+    }
+  public :
+    initialized()
+    {
+      new (wrapper_address()) wrapper();
+    }
+    initialized(initialized const & arg)
+    {
+      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
+    }
+    explicit initialized(T const & arg)
+    {
+      new (wrapper_address()) wrapper(arg);
+    }
+    initialized & operator=(initialized const & arg)
+    {
+      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((! is_const<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_123;
+      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
+      return *this;
+    }
+    ~initialized()
+    {
+      wrapper_address()->wrapper::~wrapper();
+    }
+    T const & data() const
+    {
+      return wrapper_address()->data;
+    }
+    T& data()
+    {
+      return wrapper_address()->data;
+    }
+    void swap(initialized & arg)
+    {
+      ::boost::swap( this->data(), arg.data() );
+    }
+    operator T const &() const
+    {
+      return wrapper_address()->data;
+    }
+    operator T&()
+    {
+      return wrapper_address()->data;
+    }
+} ;
+template<class T>
+T const& get ( initialized<T> const& x )
+{
+  return x.data() ;
+}
+template<class T>
+T& get ( initialized<T>& x )
+{
+  return x.data() ;
+}
+template<class T>
+void swap ( initialized<T> & lhs, initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+template<class T>
+class value_initialized
+{
+  private :
+    initialized<T> m_data;
+  public :
+    value_initialized()
+    :
+    m_data()
+    { }
+    T const & data() const
+    {
+      return m_data.data();
+    }
+    T& data()
+    {
+      return m_data.data();
+    }
+    void swap(value_initialized & arg)
+    {
+      m_data.swap(arg.m_data);
+    }
+    operator T const &() const
+    {
+      return m_data;
+    }
+    operator T&()
+    {
+      return m_data;
+    }
+} ;
+template<class T>
+T const& get ( value_initialized<T> const& x )
+{
+  return x.data() ;
+}
+template<class T>
+T& get ( value_initialized<T>& x )
+{
+  return x.data() ;
+}
+template<class T>
+void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+class initialized_value_t
+{
+  public :
+    template <class T> operator T() const
+    {
+      return initialized<T>().data();
+    }
+};
+initialized_value_t const initialized_value = {} ;
+}
+namespace boost { namespace spirit { namespace traits
+{
+    namespace detail
+    {
+        template <typename T, typename Expected>
+        struct value_type_is_substitute
+          : is_substitute<
+                typename container_value<T>::type
+              , typename container_value<Expected>::type>
+        {};
+        template <typename T, typename Expected, typename Enable = void>
+        struct is_substitute_impl : is_same<T, Expected> {};
+        template <typename T, typename Expected>
+        struct is_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<T>,
+                    fusion::traits::is_sequence<Expected>,
+                    mpl::equal<T, Expected, is_substitute<mpl::_1, mpl::_2> >
+                >
+            >::type>
+          : mpl::true_ {};
+        template <typename T, typename Expected>
+        struct is_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    is_container<T>,
+                    is_container<Expected>,
+                    detail::value_type_is_substitute<T, Expected>
+                >
+            >::type>
+          : mpl::true_ {};
+    }
+    template <typename T, typename Expected, typename Enable >
+    struct is_substitute
+      : detail::is_substitute_impl<T, Expected> {};
+    template <typename T, typename Expected>
+    struct is_substitute<optional<T>, optional<Expected> >
+      : is_substitute<T, Expected> {};
+    template <typename T>
+    struct is_substitute<T, T
+          , typename enable_if<not_is_optional<T> >::type>
+      : mpl::true_ {};
+    namespace detail
+    {
+        template <typename T, typename Expected, typename Enable = void>
+        struct is_weak_substitute_impl : is_convertible<T, Expected> {};
+        template <typename T, typename Expected>
+        struct value_type_is_weak_substitute
+          : is_weak_substitute<
+                typename container_value<T>::type
+              , typename container_value<Expected>::type>
+        {};
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    is_container<T>
+                  , is_container<Expected>
+                  , value_type_is_weak_substitute<T, Expected> >
+            >::type>
+          : mpl::true_ {};
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<T>
+                  , fusion::traits::is_sequence<Expected>
+                  , mpl::equal<T, Expected, is_weak_substitute<mpl::_1, mpl::_2> > >
+            >::type>
+          : mpl::true_ {};
+        template <typename T, typename Expected>
+        struct is_weak_substitute_impl<T, Expected,
+            typename enable_if<
+                mpl::and_<
+                    mpl::not_<fusion::traits::is_sequence<T> >
+                  , fusion::traits::is_sequence<Expected> >
+            >::type>
+          : mpl::false_ {};
+    }
+    template <typename T, typename Expected, typename Enable >
+    struct is_weak_substitute
+      : detail::is_weak_substitute_impl<T, Expected> {};
+    template <typename T, typename Expected>
+    struct is_weak_substitute<optional<T>, optional<Expected> >
+      : is_weak_substitute<T, Expected> {};
+    template <typename T, typename Expected>
+    struct is_weak_substitute<optional<T>, Expected>
+      : is_weak_substitute<T, Expected> {};
+    template <typename T, typename Expected>
+    struct is_weak_substitute<T, optional<Expected> >
+      : is_weak_substitute<T, Expected> {};
+    template <typename Expected>
+    struct is_weak_substitute<boost::detail::variant::void_, Expected>
+      : mpl::true_
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename Expected>
+    struct is_weak_substitute<
+            boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>, Expected>
+      : mpl::bool_<
+ is_weak_substitute<T0, Expected>::type::value && is_weak_substitute<T1, Expected>::type::value && is_weak_substitute<T2, Expected>::type::value && is_weak_substitute<T3, Expected>::type::value && is_weak_substitute<T4, Expected>::type::value && is_weak_substitute<T5, Expected>::type::value && is_weak_substitute<T6, Expected>::type::value && is_weak_substitute<T7, Expected>::type::value && is_weak_substitute<T8, Expected>::type::value && is_weak_substitute<T9, Expected>::type::value && is_weak_substitute<T10, Expected>::type::value && is_weak_substitute<T11, Expected>::type::value && is_weak_substitute<T12, Expected>::type::value && is_weak_substitute<T13, Expected>::type::value && is_weak_substitute<T14, Expected>::type::value && is_weak_substitute<T15, Expected>::type::value && is_weak_substitute<T16, Expected>::type::value && is_weak_substitute<T17, Expected>::type::value && is_weak_substitute<T18, Expected>::type::value && is_weak_substitute<T19, Expected>::type::value && true>
+    {};
+    template <typename T>
+    struct is_weak_substitute<T, T
+          , typename enable_if<
+                mpl::and_<not_is_optional<T>, not_is_variant<T> >
+            >::type>
+      : mpl::true_ {};
+    template <typename T, typename Enable >
+    struct is_proxy : mpl::false_ {};
+    template <typename T>
+    struct is_proxy<T,
+        typename enable_if<
+            mpl::and_<
+                fusion::traits::is_sequence<T>,
+                fusion::traits::is_view<T>
+            >
+        >::type>
+      : mpl::true_ {};
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_adapted_variant_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::adapted_variant_tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename T, typename Domain, typename Enable >
+    struct not_is_variant
+      : mpl::not_<detail::has_adapted_variant_tag<T> >
+    {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename Domain>
+    struct not_is_variant<boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>, Domain>
+      : mpl::false_
+    {};
+    template <typename T, typename Domain>
+    struct not_is_variant<boost::optional<T>, Domain>
+      : not_is_variant<T, Domain>
+    {};
+    template <typename T>
+    struct variant_type
+      : mpl::identity<T>
+    {};
+    template <typename T>
+    struct variant_type<boost::optional<T> >
+      : variant_type<T>
+    {};
+    namespace detail
+    {
+        template <typename Expected, typename Attribute>
+        struct attribute_is_compatible
+          : is_convertible<Attribute, Expected>
+        {};
+        template <typename Expected, typename Attribute>
+        struct attribute_is_compatible<Expected, boost::optional<Attribute> >
+          : is_convertible<Attribute, Expected>
+        {};
+        template <typename Container>
+        struct is_hold_any_container
+          : traits::is_hold_any<typename traits::container_value<Container>::type>
+        {};
+    }
+    template <typename Attribute, typename Expected
+      , typename IsNotVariant = mpl::false_, typename Enable = void>
+    struct compute_compatible_component_variant
+      : mpl::or_<
+            traits::detail::attribute_is_compatible<Expected, Attribute>
+          , traits::is_hold_any<Expected>
+          , mpl::eval_if<
+                is_container<Expected>
+              , traits::detail::is_hold_any_container<Expected>
+              , mpl::false_> >
+    {};
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_types { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::types>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename Variant, typename Expected>
+    struct compute_compatible_component_variant<Variant, Expected, mpl::false_
+      , typename enable_if<detail::has_types<Variant> >::type>
+    {
+        typedef typename traits::variant_type<Variant>::type variant_type;
+        typedef typename variant_type::types types;
+        typedef typename mpl::end<types>::type end;
+        typedef typename
+            mpl::find_if<types, is_same<Expected, mpl::_1> >::type
+        iter;
+        typedef typename mpl::distance<
+            typename mpl::begin<types>::type, iter
+        >::type distance;
+        typedef typename mpl::not_<is_same<iter, end> >::type type;
+        enum { value = type::value };
+        typedef typename
+            mpl::eval_if<type, mpl::deref<iter>, mpl::identity<unused_type> >::type
+        compatible_type;
+        static bool is_compatible(int which)
+        {
+            return which == distance::value;
+        }
+    };
+    template <typename Expected, typename Attribute, typename Domain>
+    struct compute_compatible_component
+      : compute_compatible_component_variant<Attribute, Expected
+          , typename spirit::traits::not_is_variant<Attribute, Domain>::type> {};
+    template <typename Expected, typename Domain>
+    struct compute_compatible_component<Expected, unused_type, Domain>
+      : mpl::false_ {};
+    template <typename Attribute, typename Domain>
+    struct compute_compatible_component<unused_type, Attribute, Domain>
+      : mpl::false_ {};
+    template <typename Domain>
+    struct compute_compatible_component<unused_type, unused_type, Domain>
+      : mpl::false_ {};
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct variant_which<boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> >
+    {
+        static int call(boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> const& v)
+        {
+            return v.which();
+        }
+    };
+    template <typename T>
+    int which(T const& v)
+    {
+        return variant_which<T>::call(v);
+    }
+    template <typename T, typename Domain, typename Enable >
+    struct not_is_optional
+      : mpl::true_
+    {};
+    template <typename T, typename Domain>
+    struct not_is_optional<boost::optional<T>, Domain>
+      : mpl::false_
+    {};
+    template <typename Component
+      , typename Context = unused_type, typename Iterator = unused_type>
+    struct attribute_of
+    {
+        typedef typename Component::template
+            attribute<Context, Iterator>::type type;
+    };
+    template <typename Context, typename Iterator = unused_type>
+    struct attribute_not_unused
+    {
+        template <typename Component>
+        struct apply
+          : not_is_unused<typename
+                attribute_of<Component, Context, Iterator>::type>
+        {};
+    };
+    template <typename Attribute, typename Enable >
+    struct attribute_type : mpl::identity<Attribute> {};
+    template <typename T>
+    struct sequence_size
+      : fusion::result_of::size<T>
+    {};
+    template <>
+    struct sequence_size<unused_type>
+      : mpl::int_<0>
+    {};
+    namespace detail
+    {
+        template <typename Attribute, typename Enable = void>
+        struct attribute_size_impl
+        {
+            typedef std::size_t type;
+            static type call(Attribute const&)
+            {
+                return 1;
+            }
+        };
+        template <typename Attribute>
+        struct attribute_size_impl<Attribute
+          , typename enable_if<
+                mpl::and_<
+                    fusion::traits::is_sequence<Attribute>
+                  , mpl::not_<traits::is_container<Attribute> >
+                >
+            >::type>
+        {
+            typedef typename fusion::result_of::size<Attribute>::value_type type;
+            static type call(Attribute const& attr)
+            {
+                return fusion::size(attr);
+            }
+        };
+        template <typename Attribute>
+        struct attribute_size_impl<Attribute
+          , typename enable_if<
+                mpl::and_<
+                    traits::is_container<Attribute>
+                  , mpl::not_<traits::is_iterator_range<Attribute> >
+                >
+            >::type>
+        {
+            typedef typename Attribute::size_type type;
+            static type call(Attribute const& attr)
+            {
+                return attr.size();
+            }
+        };
+    }
+    template <typename Attribute, typename Enable >
+    struct attribute_size
+      : detail::attribute_size_impl<Attribute>
+    {};
+    template <typename Attribute>
+    struct attribute_size<optional<Attribute> >
+    {
+        typedef typename attribute_size<Attribute>::type type;
+        static type call(optional<Attribute> const& val)
+        {
+            if (!val)
+                return 0;
+            return val.get();
+        }
+    };
+    template <typename Iterator>
+    struct attribute_size<iterator_range<Iterator> >
+    {
+        typedef typename boost::detail::iterator_traits<Iterator>::
+            difference_type type;
+        static type call(iterator_range<Iterator> const& r)
+        {
+            return boost::detail::distance(r.begin(), r.end());
+        }
+    };
+    template <>
+    struct attribute_size<unused_type>
+    {
+        typedef std::size_t type;
+        static type call(unused_type)
+        {
+            return 0;
+        }
+    };
+    template <typename Attribute>
+    typename attribute_size<Attribute>::type
+    size (Attribute const& attr)
+    {
+        return attribute_size<Attribute>::call(attr);
+    }
+    template <typename Component, typename Attribute, typename Enable >
+    struct pass_attribute
+    {
+        typedef fusion::vector1<Attribute&> type;
+    };
+    template <typename Attribute, typename Force = mpl::false_>
+    struct wrap_if_not_tuple
+      : mpl::if_<
+            fusion::traits::is_sequence<Attribute>
+          , Attribute&, fusion::vector1<Attribute&> >
+    {};
+    template <typename Attribute>
+    struct wrap_if_not_tuple<Attribute, mpl::true_>
+    {
+        typedef fusion::vector1<Attribute&> type;
+    };
+    template <>
+    struct wrap_if_not_tuple<unused_type, mpl::false_>
+    {
+        typedef unused_type type;
+    };
+    template <>
+    struct wrap_if_not_tuple<unused_type const, mpl::false_>
+    {
+        typedef unused_type type;
+    };
+    template <typename T>
+    struct build_optional
+    {
+        typedef boost::optional<T> type;
+    };
+    template <typename T>
+    struct build_optional<boost::optional<T> >
+    {
+        typedef boost::optional<T> type;
+    };
+    template <>
+    struct build_optional<unused_type>
+    {
+        typedef unused_type type;
+    };
+    template <typename T>
+    struct build_std_vector
+    {
+        typedef std::vector<T> type;
+    };
+    template <>
+    struct build_std_vector<unused_type>
+    {
+        typedef unused_type type;
+    };
+    template <typename Sequence>
+    struct filter_unused_attributes
+      : fusion::result_of::filter_if<Sequence, not_is_unused<mpl::_> >
+    {};
+    template <typename Attribute, typename Domain>
+    struct sequence_attribute_transform
+      : mpl::identity<Attribute>
+    {};
+    template <typename Attribute, typename Domain>
+    struct permutation_attribute_transform
+      : traits::build_optional<Attribute>
+    {};
+    template <typename Attribute, typename Domain>
+    struct sequential_or_attribute_transform
+      : traits::build_optional<Attribute>
+    {};
+    template <typename Sequence>
+    struct build_fusion_vector
+    {
+        typedef typename
+            filter_unused_attributes<Sequence>::type
+        filtered_attributes;
+        typedef typename
+            mpl::eval_if<
+                fusion::result_of::empty<filtered_attributes>
+              , mpl::identity<unused_type>
+              , fusion::result_of::as_vector<filtered_attributes>
+            >::type
+        type;
+    };
+    template <>
+    struct build_fusion_vector<unused_type>
+    {
+        typedef unused_type type;
+    };
+    template <typename Sequence, typename Context
+      , template <typename T, typename D> class Transform
+      , typename Iterator = unused_type, typename Domain = unused_type>
+    struct build_attribute_sequence
+    {
+        struct element_attribute
+        {
+            template <typename T>
+            struct result;
+            template <typename F, typename Element>
+            struct result<F(Element)>
+            {
+                typedef typename
+                    Transform<
+                        typename attribute_of<Element, Context, Iterator>::type
+                      , Domain
+                    >::type
+                type;
+            };
+        };
+        typedef typename
+            fusion::result_of::transform<Sequence, element_attribute>::type
+        type;
+    };
+    template <typename Sequence>
+    struct has_no_unused
+      : is_same<
+            typename mpl::find_if<Sequence, is_same<mpl::_, unused_type> >::type
+          , typename mpl::end<Sequence>::type>
+    {};
+    namespace detail
+    {
+        template <typename Sequence, bool no_unused
+            , int size = mpl::size<Sequence>::value>
+        struct build_collapsed_variant;
+        template <typename Sequence, int size>
+        struct build_collapsed_variant<Sequence, true, size>
+            : spirit::detail::as_variant<Sequence> {};
+        template <typename Sequence, int size>
+        struct build_collapsed_variant<Sequence, false, size>
+        {
+            typedef boost::optional<
+                typename spirit::detail::as_variant<
+                    typename fusion::result_of::pop_front<Sequence>::type
+                >::type
+            > type;
+        };
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, true, 1>
+            : mpl::front<Sequence> {};
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, false, 1>
+            : mpl::front<Sequence> {};
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, true, 2>
+            : spirit::detail::as_variant<Sequence> {};
+        template <typename Sequence>
+        struct build_collapsed_variant<Sequence, false, 2>
+        {
+            typedef boost::optional<
+                typename mpl::deref<
+                    typename mpl::next<
+                        typename mpl::begin<Sequence>::type
+                    >::type
+                >::type
+            >
+            type;
+        };
+    }
+    template <typename Attribute, typename Domain>
+    struct alternative_attribute_transform
+      : mpl::identity<Attribute>
+    {};
+    template <typename Sequence>
+    struct build_variant
+    {
+        typedef typename
+            filter_unused_attributes<Sequence>::type
+        filtered_attributes;
+        typedef has_no_unused<Sequence> no_unused;
+        typedef typename
+            mpl::eval_if<
+                no_unused,
+                mpl::identity<Sequence>,
+                fusion::result_of::push_front<filtered_attributes, unused_type>
+            >::type
+        attribute_sequence;
+        typedef typename
+            mpl::fold<
+                attribute_sequence, mpl::vector<>,
+                mpl::if_<
+                    mpl::contains<mpl::_1, mpl::_2>,
+                    mpl::_1, mpl::push_back<mpl::_1, mpl::_2>
+                >
+            >::type
+        no_duplicates;
+        typedef typename
+            traits::detail::build_collapsed_variant<
+                no_duplicates, no_unused::value>::type
+        type;
+    };
+    template <typename Exposed, typename Transformed, typename Domain
+      , typename Enable >
+    struct transform_attribute;
+    template <typename Domain, typename Transformed, typename Exposed>
+    typename spirit::result_of::pre_transform<Exposed, Transformed, Domain>::type
+    pre_transform(Exposed& attr )
+    {
+        return transform_attribute<Exposed, Transformed, Domain>::pre(attr);
+    }
+    template <typename Domain, typename Transformed, typename Exposed>
+    typename spirit::result_of::pre_transform<Exposed const, Transformed, Domain>::type
+    pre_transform(Exposed const& attr)
+    {
+        return transform_attribute<Exposed const, Transformed, Domain>::pre(attr);
+    }
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute
+    {
+        typedef typename remove_const<Attribute>::type attribute_type;
+        typedef typename
+            mpl::if_<
+                is_same<typename remove_const<ActualAttribute>::type, unused_type>
+              , attribute_type
+              , ActualAttribute&>::type
+        type;
+        typedef typename
+            mpl::if_<
+                is_same<typename remove_const<ActualAttribute>::type, unused_type>
+              , attribute_type
+              , ActualAttribute>::type
+        value_type;
+        static Attribute call(unused_type)
+        {
+            return boost::get(value_initialized<attribute_type>());
+        }
+        template <typename T>
+        static T& call(T& value)
+        {
+            return value;
+        }
+    };
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute<Attribute&, ActualAttribute>
+      : make_attribute<Attribute, ActualAttribute>
+    {};
+    template <typename Attribute, typename ActualAttribute>
+    struct make_attribute<Attribute const&, ActualAttribute>
+      : make_attribute<Attribute const, ActualAttribute>
+    {};
+    template <typename ActualAttribute>
+    struct make_attribute<unused_type, ActualAttribute>
+    {
+        typedef unused_type type;
+        typedef unused_type value_type;
+        static unused_type call(unused_type)
+        {
+            return unused;
+        }
+    };
+    template <typename A, typename B>
+    void swap_impl(A& a, B& b)
+    {
+        A temp = a;
+        a = b;
+        b = temp;
+    }
+    template <typename T>
+    void swap_impl(T& a, T& b)
+    {
+        using namespace std;
+        swap(a, b);
+    }
+    template <typename A>
+    void swap_impl(A&, unused_type)
+    {
+    }
+    template <typename A>
+    void swap_impl(unused_type, A&)
+    {
+    }
+    inline void swap_impl(unused_type, unused_type)
+    {
+    }
+    template <typename T>
+    struct strip_single_element_vector
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct strip_single_element_vector<fusion::vector1<T> >
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct strip_single_element_vector<fusion::vector<T> >
+    {
+        typedef T type;
+    };
+    template <typename T
+      , bool IsFusionSeq = fusion::traits::is_sequence<T>::value
+      , bool IsProtoExpr = proto::is_expr<T>::value>
+    struct one_element_sequence
+      : mpl::false_
+    {};
+    template <typename T>
+    struct one_element_sequence<T, true, false>
+      : mpl::bool_<mpl::size<T>::value == 1>
+    {};
+    template <typename T>
+    void clear(T& val);
+    namespace detail
+    {
+        struct clear_visitor : static_visitor<>
+        {
+            template <typename T>
+            void operator()(T& val) const
+            {
+                spirit::traits::clear(val);
+            }
+        };
+        template <typename T>
+        void clear_impl2(T& val, mpl::false_)
+        {
+            val = T();
+        }
+        template <typename T>
+        void clear_impl2(T& val, mpl::true_)
+        {
+            fusion::for_each(val, clear_visitor());
+        }
+        template <typename T>
+        void clear_impl(T& val, mpl::false_)
+        {
+            clear_impl2(val, fusion::traits::is_sequence<T>());
+        }
+        template <typename T>
+        void clear_impl(T& val, mpl::true_)
+        {
+            val.clear();
+        }
+    }
+    template <typename T, typename Enable >
+    struct clear_value
+    {
+        static void call(T& val)
+        {
+            detail::clear_impl(val, typename is_container<T>::type());
+        }
+    };
+    template <typename T>
+    struct clear_value<boost::optional<T> >
+    {
+        static void call(boost::optional<T>& val)
+        {
+            if (val)
+                val = none_t();
+        }
+    };
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct clear_value<variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> >
+    {
+        static void call(variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>& val)
+        {
+            apply_visitor(detail::clear_visitor(), val);
+        }
+    };
+    template <typename T>
+    struct clear_value<iterator_range<T> >
+    {
+        static void call(iterator_range<T>& val)
+        {
+            val = iterator_range<T>(val.end(), val.end());
+        }
+    };
+    template <typename T>
+    void clear(T& val)
+    {
+        clear_value<T>::call(val);
+    }
+    inline void clear(unused_type)
+    {
+    }
+    namespace detail
+    {
+        template <typename Out>
+        struct print_fusion_sequence
+        {
+            print_fusion_sequence(Out& out)
+              : out(out), is_first(true) {}
+            typedef void result_type;
+            template <typename T>
+            void operator()(T const& val) const
+            {
+                if (is_first)
+                    is_first = false;
+                else
+                    out << ", ";
+                spirit::traits::print_attribute(out, val);
+            }
+            Out& out;
+            mutable bool is_first;
+        };
+        template <typename Out>
+        struct print_visitor : static_visitor<>
+        {
+            print_visitor(Out& out) : out(out) {}
+            template <typename T>
+            void operator()(T const& val) const
+            {
+                spirit::traits::print_attribute(out, val);
+            }
+            Out& out;
+        };
+    }
+    template <typename Out, typename T, typename Enable>
+    struct print_attribute_debug
+    {
+        template <typename T_>
+        static void call_impl3(Out& out, T_ const& val, mpl::false_)
+        {
+            out << val;
+        }
+        template <typename T_>
+        static void call_impl3(Out& out, T_ const& val, mpl::true_)
+        {
+            out << '[';
+            fusion::for_each(val, detail::print_fusion_sequence<Out>(out));
+            out << ']';
+        }
+        template <typename T_>
+        static void call_impl2(Out& out, T_ const& val, mpl::false_)
+        {
+            call_impl3(out, val, fusion::traits::is_sequence<T_>());
+        }
+        template <typename T_>
+        static void call_impl2(Out& out, T_ const& val, mpl::true_)
+        {
+            out << '[';
+            if (!traits::is_empty(val))
+            {
+                bool first = true;
+                typename container_iterator<T_ const>::type iend = traits::end(val);
+                for (typename container_iterator<T_ const>::type i = traits::begin(val);
+                     !traits::compare(i, iend); traits::next(i))
+                {
+                    if (!first)
+                        out << ", ";
+                    first = false;
+                    spirit::traits::print_attribute(out, traits::deref(i));
+                }
+            }
+            out << ']';
+        }
+        template <typename T_>
+        static void call_impl(Out& out, T_ const& val, mpl::false_)
+        {
+            apply_visitor(detail::print_visitor<Out>(out), val);
+        }
+        template <typename T_>
+        static void call_impl(Out& out, T_ const& val, mpl::true_)
+        {
+            call_impl2(out, val, is_container<T_>());
+        }
+        static void call(Out& out, T const& val)
+        {
+            call_impl(out, val, not_is_variant<T>());
+        }
+    };
+    template <typename Out, typename T>
+    struct print_attribute_debug<Out, boost::optional<T> >
+    {
+        static void call(Out& out, boost::optional<T> const& val)
+        {
+            if (val)
+                spirit::traits::print_attribute(out, *val);
+            else
+                out << "[empty]";
+        }
+    };
+    template <typename Out, typename T>
+    inline void print_attribute(Out& out, T const& val)
+    {
+        print_attribute_debug<Out, T>::call(out, val);
+    }
+    template <typename Out>
+    inline void print_attribute(Out&, unused_type)
+    {
+    }
+    namespace detail
+    {
+        struct token_printer_debug_for_chars
+        {
+            template<typename Out, typename Char>
+            static void print(Out& o, Char c)
+            {
+                using namespace std;
+                if (c == static_cast<Char>('\a'))
+                    o << "\\a";
+                else if (c == static_cast<Char>('\b'))
+                    o << "\\b";
+                else if (c == static_cast<Char>('\f'))
+                    o << "\\f";
+                else if (c == static_cast<Char>('\n'))
+                    o << "\\n";
+                else if (c == static_cast<Char>('\r'))
+                    o << "\\r";
+                else if (c == static_cast<Char>('\t'))
+                    o << "\\t";
+                else if (c == static_cast<Char>('\v'))
+                    o << "\\v";
+                else if (c >= 0 && c < 127 && iscntrl(c))
+                    o << "\\" << std::oct << static_cast<int>(c);
+                else
+                    o << static_cast<char>(c);
+            }
+        };
+        struct token_printer_debug
+        {
+            template<typename Out, typename T>
+            static void print(Out& o, T const& val)
+            {
+                o << val;
+            }
+        };
+    }
+    template <typename T, typename Enable>
+    struct token_printer_debug
+      : mpl::if_<
+            mpl::and_<
+                is_convertible<T, char>, is_convertible<char, T> >
+          , detail::token_printer_debug_for_chars
+          , detail::token_printer_debug>::type
+    {};
+    template <typename Out, typename T>
+    inline void print_token(Out& out, T const& val)
+    {
+        token_printer_debug<T>::print(out, val);
+    }
+}}}
+namespace boost { namespace spirit { namespace result_of
+{
+    template <typename Exposed, typename Transformed, typename Domain>
+    struct pre_transform
+      : traits::transform_attribute<Exposed, Transformed, Domain>
+    {};
+}}}
+namespace boost { namespace spirit
+{
+    class utree;
+}}
+namespace boost
+{
+    template <typename T>
+    inline T get(boost::spirit::utree const& x);
+}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Exposed, typename Transformed>
+    struct default_transform_attribute
+    {
+        typedef Transformed type;
+        static Transformed pre(Exposed&) { return Transformed(); }
+        static void post(Exposed& val, Transformed const& attr)
+        {
+            traits::assign_to(attr, val);
+        }
+        static void fail(Exposed&) {}
+    };
+    template <typename Attribute>
+    struct default_transform_attribute<Attribute, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+    template <typename Exposed, typename Transformed>
+    struct proxy_transform_attribute
+    {
+        typedef Transformed type;
+        static Transformed pre(Exposed& val) { return Transformed(val); }
+        static void post(Exposed&, Transformed const&) { }
+        static void fail(Exposed&) {}
+    };
+    template <typename Attribute>
+    struct proxy_transform_attribute<Attribute, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+    template <typename Exposed, typename Transformed, typename Enable = void>
+    struct transform_attribute
+      : mpl::if_<
+            mpl::and_<
+                mpl::not_<is_const<Exposed> >
+              , mpl::not_<is_reference<Exposed> >
+              , traits::is_proxy<Transformed> >
+          , proxy_transform_attribute<Exposed, Transformed>
+          , default_transform_attribute<Exposed, Transformed>
+        >::type
+    {};
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<boost::optional<Exposed>, Transformed
+      , typename disable_if<is_same<boost::optional<Exposed>, Transformed> >::type>
+    {
+        typedef Transformed& type;
+        static Transformed& pre(boost::optional<Exposed>& val)
+        {
+            if (!val)
+                val = Transformed();
+            return boost::get<Transformed>(val);
+        }
+        static void post(boost::optional<Exposed>&, Transformed const&) {}
+        static void fail(boost::optional<Exposed>& val)
+        {
+             val = none_t();
+        }
+    };
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute>
+    {
+        typedef Attribute& type;
+        static Attribute& pre(Attribute& val) { return val; }
+        static void post(Attribute&, Attribute const&) {}
+        static void fail(Attribute&) {}
+    };
+    template <>
+    struct transform_attribute<unused_type, unused_type>
+    {
+        typedef unused_type type;
+        static unused_type pre(unused_type) { return unused; }
+        static void post(unused_type, unused_type) {}
+        static void fail(unused_type) {}
+    };
+    template <>
+    struct transform_attribute<unused_type const, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+    template <typename Attribute>
+    struct transform_attribute<unused_type, Attribute>
+      : transform_attribute<unused_type, unused_type>
+    {};
+    template <typename Attribute>
+    struct transform_attribute<unused_type const, Attribute>
+      : transform_attribute<unused_type, unused_type>
+    {};
+    template <typename Attribute>
+    struct transform_attribute<Attribute, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+    template <typename Attribute>
+    struct transform_attribute<Attribute const, unused_type>
+      : transform_attribute<unused_type, unused_type>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed, Transformed, qi::domain>
+      : qi::transform_attribute<Exposed, Transformed>
+    {};
+    template <typename Exposed, typename Transformed>
+    struct transform_attribute<Exposed&, Transformed, qi::domain>
+      : transform_attribute<Exposed, Transformed, qi::domain>
+    {};
+    template <typename Attribute>
+    struct transform_attribute<Attribute&, Attribute, qi::domain>
+      : qi::transform_attribute<Attribute&, Attribute>
+    {};
+    template <typename Exposed, typename Transformed>
+    void post_transform(Exposed& dest, Transformed const& attr)
+    {
+        return transform_attribute<Exposed, Transformed, qi::domain>::post(dest, attr);
+    }
+    template <typename Exposed, typename Transformed>
+    void fail_transform(Exposed& dest, Transformed const&)
+    {
+        return transform_attribute<Exposed, Transformed, qi::domain>::fail(dest);
+    }
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Component>
+    struct action_dispatch
+    {
+        template <typename F, typename Attribute, typename Context>
+        bool operator()(F const& f, Attribute& attr, Context& context)
+        {
+            bool pass = true;
+            f(attr, context, pass);
+            return pass;
+        }
+        template <typename Eval, typename Attribute, typename Context>
+        bool operator()(phoenix::actor<Eval> const& f
+          , Attribute& attr, Context& context)
+        {
+            bool pass = true;
+            typename pass_attribute<Component, Attribute>::type attr_wrap(attr);
+            f(attr_wrap, context, pass);
+            return pass;
+        }
+        template <typename RT, typename A0, typename A1, typename A2
+          , typename Attribute, typename Context>
+        bool operator()(RT(*f)(A0, A1, A2), Attribute& attr, Context& context)
+        {
+            bool pass = true;
+            f(attr, context, pass);
+            return pass;
+        }
+        template <typename RT, typename A0, typename A1
+          , typename Attribute, typename Context>
+        bool operator()(RT(*f)(A0, A1), Attribute& attr, Context& context)
+        {
+            f(attr, context);
+            return true;
+        }
+        template <typename RT, typename A0, typename Attribute, typename Context>
+        bool operator()(RT(*f)(A0), Attribute& attr, Context&)
+        {
+            f(attr);
+            return true;
+        }
+        template <typename RT, typename Attribute, typename Context>
+        bool operator()(RT(*f)(), Attribute&, Context&)
+        {
+            f();
+            return true;
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Attribute, typename Context
+            , typename Iterator, typename Enable>
+    struct handles_container : mpl::false_ {};
+    template <typename Subject, typename Attribute, typename Context
+            , typename Iterator>
+    struct unary_handles_container
+      : handles_container<Subject, Attribute, Context, Iterator> {};
+    template <typename Left, typename Right, typename Attribute
+            , typename Context, typename Iterator>
+    struct binary_handles_container
+      : mpl::or_<
+            handles_container<Left, Attribute, Context, Iterator>
+          , handles_container<Right, Attribute, Context, Iterator> >
+    {};
+    template <typename Elements, typename Attribute, typename Context
+            , typename Iterator>
+    struct nary_handles_container
+      : mpl::not_<
+            is_same<
+                typename mpl::find_if<
+                    Elements, handles_container<mpl::_, Attribute
+                                              , Context, Iterator>
+                >::type
+              , typename mpl::end<Elements>::type> >
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::_0_type; using spirit::_0; using spirit::_1_type; using spirit::_1; using spirit::_2_type; using spirit::_2; using spirit::_3_type; using spirit::_3; using spirit::_4_type; using spirit::_4; using spirit::_5_type; using spirit::_5; using spirit::_6_type; using spirit::_6; using spirit::_7_type; using spirit::_7; using spirit::_8_type; using spirit::_8; using spirit::_9_type; using spirit::_9;
+    template <typename Subject, typename Action>
+    struct action : unary_parser<action<Subject, Action> >
+    {
+        typedef Subject subject_type;
+        typedef Action action_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+          : traits::attribute_of<Subject, Context, Iterator>
+        {};
+        action(Subject const& subject, Action f)
+          : subject(subject), f(f) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr_) const
+        {
+            typedef typename attribute<Context, Iterator>::type attr_type;
+            typedef traits::make_attribute<attr_type, Attribute> make_attribute;
+            typedef traits::transform_attribute<
+                typename make_attribute::type, attr_type, domain> transform;
+            typename make_attribute::type made_attr = make_attribute::call(attr_);
+            typename transform::type attr = transform::pre(made_attr);
+            Iterator save = first;
+            if (subject.parse(first, last, context, skipper, attr))
+            {
+                if (traits::action_dispatch<Subject>()(f, attr, context))
+                {
+                    traits::post_transform(attr_, attr);
+                    return true;
+                }
+                first = save;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return subject.what(context);
+        }
+        Subject subject;
+        Action f;
+    private:
+        action& operator= (action const&);
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct make_component<qi::domain, tag::action>
+    {
+        template <typename Sig>
+        struct result;
+        template <typename This, typename Elements, typename Modifiers>
+        struct result<This(Elements, Modifiers)>
+        {
+            typedef typename
+                remove_const<typename Elements::car_type>::type
+            subject_type;
+            typedef typename
+                remove_const<typename Elements::cdr_type::car_type>::type
+            action_type;
+            typedef qi::action<subject_type, action_type> type;
+        };
+        template <typename Elements>
+        typename result<make_component(Elements, unused_type)>::type
+        operator()(Elements const& elements, unused_type) const
+        {
+            typename result<make_component(Elements, unused_type)>::type
+                result(elements.car, elements.cdr.car);
+            return result;
+        }
+    };
+}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename Action>
+    struct has_semantic_action<qi::action<Subject, Action> >
+      : mpl::true_ {};
+    template <typename Subject, typename Action, typename Attribute
+        , typename Context, typename Iterator>
+    struct handles_container<qi::action<Subject, Action>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace phoenix { namespace detail
+{
+    template <int N>
+    struct function_eval;
+    template <>
+    struct function_eval<0>
+    {
+        template <typename Env, typename F>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename fn::result_type type;
+        };
+        template <typename RT, typename Env, typename F>
+        static RT
+        eval(Env const& env, F const& f)
+        {
+            return f.eval(env)();
+        }
+    };
+    template <typename T>
+    T& help_rvalue_deduction(T& x)
+    {
+        return x;
+    }
+    template <typename T>
+    T const& help_rvalue_deduction(T const& x)
+    {
+        return x;
+    }
+    template <>
+    struct function_eval<1>
+    {
+        template <typename Env, typename F
+          , typename A0>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0;
+            typedef mpl::vector1
+                < a0>
+            args;
+            typedef typename
+                fn::template result< a0>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<2>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1;
+            typedef mpl::vector2
+                < a0 , a1>
+            args;
+            typedef typename
+                fn::template result< a0 , a1>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<3>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2;
+            typedef mpl::vector3
+                < a0 , a1 , a2>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<4>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3;
+            typedef mpl::vector4
+                < a0 , a1 , a2 , a3>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<5>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3; typedef typename remove_reference< typename A4::template result<Env>::type >::type a4;
+            typedef mpl::vector5
+                < a0 , a1 , a2 , a3 , a4>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3 , a4>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3 , A4 & _4)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)) , help_rvalue_deduction(_4.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<6>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3; typedef typename remove_reference< typename A4::template result<Env>::type >::type a4; typedef typename remove_reference< typename A5::template result<Env>::type >::type a5;
+            typedef mpl::vector6
+                < a0 , a1 , a2 , a3 , a4 , a5>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3 , a4 , a5>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3 , A4 & _4 , A5 & _5)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)) , help_rvalue_deduction(_4.eval(env)) , help_rvalue_deduction(_5.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<7>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3; typedef typename remove_reference< typename A4::template result<Env>::type >::type a4; typedef typename remove_reference< typename A5::template result<Env>::type >::type a5; typedef typename remove_reference< typename A6::template result<Env>::type >::type a6;
+            typedef mpl::vector7
+                < a0 , a1 , a2 , a3 , a4 , a5 , a6>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3 , a4 , a5 , a6>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3 , A4 & _4 , A5 & _5 , A6 & _6)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)) , help_rvalue_deduction(_4.eval(env)) , help_rvalue_deduction(_5.eval(env)) , help_rvalue_deduction(_6.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<8>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3; typedef typename remove_reference< typename A4::template result<Env>::type >::type a4; typedef typename remove_reference< typename A5::template result<Env>::type >::type a5; typedef typename remove_reference< typename A6::template result<Env>::type >::type a6; typedef typename remove_reference< typename A7::template result<Env>::type >::type a7;
+            typedef mpl::vector8
+                < a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3 , A4 & _4 , A5 & _5 , A6 & _6 , A7 & _7)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)) , help_rvalue_deduction(_4.eval(env)) , help_rvalue_deduction(_5.eval(env)) , help_rvalue_deduction(_6.eval(env)) , help_rvalue_deduction(_7.eval(env)));
+        }
+    };
+    template <>
+    struct function_eval<9>
+    {
+        template <typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        struct result
+        {
+            typedef typename
+                remove_reference<
+                    typename F::template result<Env>::type
+                >::type
+            fn;
+            typedef typename remove_reference< typename A0::template result<Env>::type >::type a0; typedef typename remove_reference< typename A1::template result<Env>::type >::type a1; typedef typename remove_reference< typename A2::template result<Env>::type >::type a2; typedef typename remove_reference< typename A3::template result<Env>::type >::type a3; typedef typename remove_reference< typename A4::template result<Env>::type >::type a4; typedef typename remove_reference< typename A5::template result<Env>::type >::type a5; typedef typename remove_reference< typename A6::template result<Env>::type >::type a6; typedef typename remove_reference< typename A7::template result<Env>::type >::type a7; typedef typename remove_reference< typename A8::template result<Env>::type >::type a8;
+            typedef mpl::vector9
+                < a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8>
+            args;
+            typedef typename
+                fn::template result< a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8>
+            function_apply;
+            typedef typename
+                mpl::eval_if<
+                    is_same<
+                        typename mpl::find<args, fusion::void_>::type
+                      , typename mpl::end<args>::type>
+                  , function_apply
+                  , mpl::identity<fusion::void_>
+                >::type
+            type;
+        };
+        template <typename RT, typename Env, typename F
+          , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        static RT
+        eval(Env const& env, F const& f
+          , A0 & _0 , A1 & _1 , A2 & _2 , A3 & _3 , A4 & _4 , A5 & _5 , A6 & _6 , A7 & _7 , A8 & _8)
+        {
+            return f.eval(env)( help_rvalue_deduction(_0.eval(env)) , help_rvalue_deduction(_1.eval(env)) , help_rvalue_deduction(_2.eval(env)) , help_rvalue_deduction(_3.eval(env)) , help_rvalue_deduction(_4.eval(env)) , help_rvalue_deduction(_5.eval(env)) , help_rvalue_deduction(_6.eval(env)) , help_rvalue_deduction(_7.eval(env)) , help_rvalue_deduction(_8.eval(env)));
+        }
+    };
+}}}
+namespace boost { namespace phoenix
+{
+    template <typename F>
+    struct function
+    {
+        function() : f() {}
+        function(F const& f) : f(f) {}
+        actor<typename as_composite<detail::function_eval<0>, F>::type>
+        operator()() const
+        {
+            return compose<detail::function_eval<0> >(f);
+        }
+        template <typename A0>
+        actor<typename as_composite<detail::function_eval<1>, F, A0>::type>
+        operator()(A0 const& _0) const
+        {
+            return compose<detail::function_eval<1> >(f, _0);
+        }
+        template <typename A0, typename A1>
+        actor<typename as_composite<detail::function_eval<2>, F, A0, A1>::type>
+        operator()(A0 const& _0, A1 const& _1) const
+        {
+            return compose<detail::function_eval<2> >(f, _0, _1);
+        }
+    template < typename A0 , typename A1 , typename A2>
+    actor<typename as_composite<detail::function_eval<3>, F
+      , A0 , A1 , A2>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2) const
+    {
+        return compose<detail::function_eval<3> >(f, _0 , _1 , _2);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3>
+    actor<typename as_composite<detail::function_eval<4>, F
+      , A0 , A1 , A2 , A3>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3) const
+    {
+        return compose<detail::function_eval<4> >(f, _0 , _1 , _2 , _3);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    actor<typename as_composite<detail::function_eval<5>, F
+      , A0 , A1 , A2 , A3 , A4>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3 , A4 const& _4) const
+    {
+        return compose<detail::function_eval<5> >(f, _0 , _1 , _2 , _3 , _4);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    actor<typename as_composite<detail::function_eval<6>, F
+      , A0 , A1 , A2 , A3 , A4 , A5>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3 , A4 const& _4 , A5 const& _5) const
+    {
+        return compose<detail::function_eval<6> >(f, _0 , _1 , _2 , _3 , _4 , _5);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    actor<typename as_composite<detail::function_eval<7>, F
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3 , A4 const& _4 , A5 const& _5 , A6 const& _6) const
+    {
+        return compose<detail::function_eval<7> >(f, _0 , _1 , _2 , _3 , _4 , _5 , _6);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    actor<typename as_composite<detail::function_eval<8>, F
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3 , A4 const& _4 , A5 const& _5 , A6 const& _6 , A7 const& _7) const
+    {
+        return compose<detail::function_eval<8> >(f, _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7);
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    actor<typename as_composite<detail::function_eval<9>, F
+      , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type>
+    operator()( A0 const& _0 , A1 const& _1 , A2 const& _2 , A3 const& _3 , A4 const& _4 , A5 const& _5 , A6 const& _6 , A7 const& _7 , A8 const& _8) const
+    {
+        return compose<detail::function_eval<9> >(f, _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8);
+    }
+        F f;
+    };
+}}
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template <
+            typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_
+          , typename Extra = void_
+        >
+        struct make_vector;
+        template <>
+        struct make_vector<>
+        {
+            typedef vector0<> type;
+        };
+    }
+    inline vector0<>
+    make_vector()
+    {
+        return vector0<>();
+    }
+    namespace result_of
+    {
+        template <typename T0>
+        struct make_vector<T0>
+        {
+            typedef vector1<typename detail::as_fusion_element<T0>::type> type;
+        };
+    }
+    template <typename T0>
+    inline vector1<typename detail::as_fusion_element<T0>::type>
+    make_vector(T0 const& _0)
+    {
+        return vector1<typename detail::as_fusion_element<T0>::type>(
+            _0);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1>
+        struct make_vector<T0 , T1>
+        {
+            typedef vector2<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type> type;
+        };
+    }
+    template <typename T0 , typename T1>
+    inline vector2<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type>
+    make_vector(T0 const& _0 , T1 const& _1)
+    {
+        return vector2<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type>(
+            _0 , _1);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2>
+        struct make_vector<T0 , T1 , T2>
+        {
+            typedef vector3<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2>
+    inline vector3<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2)
+    {
+        return vector3<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type>(
+            _0 , _1 , _2);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3>
+        struct make_vector<T0 , T1 , T2 , T3>
+        {
+            typedef vector4<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3>
+    inline vector4<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3)
+    {
+        return vector4<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type>(
+            _0 , _1 , _2 , _3);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct make_vector<T0 , T1 , T2 , T3 , T4>
+        {
+            typedef vector5<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    inline vector5<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4)
+    {
+        return vector5<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type>(
+            _0 , _1 , _2 , _3 , _4);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct make_vector<T0 , T1 , T2 , T3 , T4 , T5>
+        {
+            typedef vector6<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    inline vector6<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5)
+    {
+        return vector6<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type>(
+            _0 , _1 , _2 , _3 , _4 , _5);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct make_vector<T0 , T1 , T2 , T3 , T4 , T5 , T6>
+        {
+            typedef vector7<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    inline vector7<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6)
+    {
+        return vector7<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type>(
+            _0 , _1 , _2 , _3 , _4 , _5 , _6);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct make_vector<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+        {
+            typedef vector8<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    inline vector8<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7)
+    {
+        return vector8<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type>(
+            _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct make_vector<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+        {
+            typedef vector9<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    inline vector9<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8)
+    {
+        return vector9<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type>(
+            _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8);
+    }
+    namespace result_of
+    {
+        template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct make_vector<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+        {
+            typedef vector10<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type , typename detail::as_fusion_element<T9>::type> type;
+        };
+    }
+    template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    inline vector10<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type , typename detail::as_fusion_element<T9>::type>
+    make_vector(T0 const& _0 , T1 const& _1 , T2 const& _2 , T3 const& _3 , T4 const& _4 , T5 const& _5 , T6 const& _6 , T7 const& _7 , T8 const& _8 , T9 const& _9)
+    {
+        return vector10<typename detail::as_fusion_element<T0>::type , typename detail::as_fusion_element<T1>::type , typename detail::as_fusion_element<T2>::type , typename detail::as_fusion_element<T3>::type , typename detail::as_fusion_element<T4>::type , typename detail::as_fusion_element<T5>::type , typename detail::as_fusion_element<T6>::type , typename detail::as_fusion_element<T7>::type , typename detail::as_fusion_element<T8>::type , typename detail::as_fusion_element<T9>::type>(
+            _0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9);
+    }
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    namespace result_of
+    {
+        using fusion::result_of::make_vector;
+    }
+    using fusion::make_vector;
+}}}
+namespace boost { namespace phoenix { namespace detail
+{
+    namespace expression
+    {
+        template <
+            typename F, typename A0 = void, typename A1 = void
+          , typename A2 = void, typename Dummy = void>
+        struct function_eval;
+        template <typename F, typename A0>
+        struct function_eval<F, A0>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<1>, F, A0
+                >::type
+            > type;
+            static type make(F f, A0 const & _0)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<1> >(f, _0);
+            }
+        };
+        template <typename F, typename A0, typename A1>
+        struct function_eval<F, A0, A1>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<2>, F, A0, A1
+                >::type
+            > type;
+            static type make(F f, A0 const & _0, A1 const & _1)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<2> >(f, _0, _1);
+            }
+        };
+        template <typename F, typename A0, typename A1, typename A2>
+        struct function_eval<F, A0, A1, A2>
+        {
+            typedef phoenix::actor<
+                typename phoenix::as_composite<
+                    phoenix::detail::function_eval<3>, F, A0, A1, A2
+                >::type
+            > type;
+            static type make(F f, A0 const & _0, A1 const & _1, A2 const & _2)
+            {
+                return phoenix::compose<
+                    phoenix::detail::function_eval<3> >(f, _0, _1, _2);
+            }
+        };
+    }
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Terminal, typename Args>
+    struct terminal_ex
+    {
+        typedef Terminal terminal_type;
+        typedef Args args_type;
+        terminal_ex(Args const& args)
+          : args(args) {}
+        terminal_ex(Args const& args, Terminal const& term)
+          : args(args), term(term) {}
+        Args args;
+        Terminal term;
+    };
+    template <typename Terminal, typename Actor, int Arity>
+    struct lazy_terminal
+    {
+        typedef Terminal terminal_type;
+        typedef Actor actor_type;
+        static int const arity = Arity;
+        lazy_terminal(Actor const& actor)
+          : actor(actor) {}
+        lazy_terminal(Actor const& actor, Terminal const& term)
+          : actor(actor), term(term) {}
+        Actor actor;
+        Terminal term;
+    };
+    template <typename Domain, typename Terminal, int Arity, typename Enable = void>
+    struct use_lazy_terminal : mpl::false_ {};
+    template <typename Domain, typename Terminal, int Arity, typename Enable = void>
+    struct use_lazy_directive : mpl::false_ {};
+    template <typename Terminal>
+    struct terminal;
+    template <typename Domain, typename Terminal>
+    struct use_terminal<Domain, terminal<Terminal> >
+        : use_terminal<Domain, Terminal> {};
+    template <typename Domain, typename Terminal, int Arity, typename Actor>
+    struct use_terminal<Domain, lazy_terminal<Terminal, Actor, Arity> >
+        : use_lazy_terminal<Domain, Terminal, Arity> {};
+    template <typename Domain, typename Terminal, int Arity, typename Actor>
+    struct use_directive<Domain, lazy_terminal<Terminal, Actor, Arity> >
+        : use_lazy_directive<Domain, Terminal, Arity> {};
+    template <
+        typename F
+      , typename A0 = unused_type
+      , typename A1 = unused_type
+      , typename A2 = unused_type
+      , typename Unused = unused_type
+    >
+    struct make_lazy;
+    template <typename F, typename A0>
+    struct make_lazy<F, A0>
+    {
+        typedef typename
+            proto::terminal<
+                lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0>::type
+                  , 1
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+        result_type
+        operator()(F f, A0 const& _0) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0>::make(f, _0)
+              , f.proto_base().child0
+            ));
+        }
+    };
+    template <typename F, typename A0, typename A1>
+    struct make_lazy<F, A0, A1>
+    {
+        typedef typename
+            proto::terminal<
+               lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0, A1>::type
+                  , 2
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+        result_type
+        operator()(F f, A0 const& _0, A1 const& _1) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0, _1)
+              , f.proto_base().child0
+            ));
+        }
+    };
+    template <typename F, typename A0, typename A1, typename A2>
+    struct make_lazy<F, A0, A1, A2>
+    {
+        typedef typename
+            proto::terminal<
+               lazy_terminal<
+                    typename F::terminal_type
+                  , typename phoenix::detail::expression::function_eval<F, A0, A1, A2>::type
+                  , 3
+                >
+            >::type
+        result_type;
+        typedef result_type type;
+        result_type
+        operator()(F f, A0 const& _0, A1 const& _1, A2 const& _2) const
+        {
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(child_type(
+                phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0, _1, _2)
+              , f.proto_base().child0
+            ));
+        }
+    };
+    namespace detail
+    {
+        template <bool C> struct bool_;
+        template <>
+        struct bool_<true> : mpl::bool_<true>
+        {
+            typedef bool_<true>* is_true;
+        };
+        template <>
+        struct bool_<false> : mpl::bool_<false>
+        {
+            typedef bool_<false>* is_false;
+        };
+        template <
+            typename A0
+          , typename A1 = unused_type
+          , typename A2 = unused_type
+        >
+        struct contains_actor
+            : bool_<
+                  phoenix::is_actor<A0>::value
+               || phoenix::is_actor<A1>::value
+               || phoenix::is_actor<A2>::value
+              >
+        {};
+        template <typename A>
+        struct to_lazy_arg
+          : phoenix::as_actor<A>
+        {};
+        template <typename A>
+        struct to_lazy_arg<const A>
+          : to_lazy_arg<A>
+        {};
+        template <typename A>
+        struct to_lazy_arg<A &>
+          : to_lazy_arg<A>
+        {};
+        template <>
+        struct to_lazy_arg<unused_type>
+        {
+            typedef unused_type type;
+        };
+        template <typename A>
+        struct to_nonlazy_arg
+        {
+            typedef A type;
+        };
+        template <typename A>
+        struct to_nonlazy_arg<const A>
+          : to_nonlazy_arg<A>
+        {};
+        template <typename A>
+        struct to_nonlazy_arg<A &>
+          : to_nonlazy_arg<A>
+        {};
+        template <>
+        struct to_nonlazy_arg<unused_type>
+        {
+            typedef fusion::void_ type;
+        };
+    }
+    template <typename Terminal>
+    struct terminal
+      : proto::extends<
+            typename proto::terminal<Terminal>::type
+          , terminal<Terminal>
+        >
+    {
+        typedef terminal<Terminal> this_type;
+        typedef Terminal terminal_type;
+        typedef proto::extends<
+            typename proto::terminal<Terminal>::type
+          , terminal<Terminal>
+        > base_type;
+        terminal() {}
+        terminal(Terminal const& t)
+          : base_type(proto::terminal<Terminal>::type::make(t))
+        {}
+        template <
+            bool Lazy
+          , typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper;
+        template <
+            typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper<false, A0, A1, A2>
+        {
+            typedef typename
+                proto::terminal<
+                    terminal_ex<
+                        Terminal
+                      , typename detail::result_of::make_vector<
+                            typename detail::to_nonlazy_arg<A0>::type
+                          , typename detail::to_nonlazy_arg<A1>::type
+                          , typename detail::to_nonlazy_arg<A2>::type>::type>
+                >::type
+            type;
+        };
+        template <
+            typename A0
+          , typename A1
+          , typename A2
+        >
+        struct result_helper<true, A0, A1, A2>
+        {
+            typedef typename
+                make_lazy<this_type
+                  , typename detail::to_lazy_arg<A0>::type
+                  , typename detail::to_lazy_arg<A1>::type
+                  , typename detail::to_lazy_arg<A2>::type>::type
+            type;
+        };
+        template <
+            typename A0
+          , typename A1 = unused_type
+          , typename A2 = unused_type
+        >
+        struct result
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, A1, A2>::value
+                  , A0, A1, A2
+                >::type
+            type;
+        };
+        template <typename This, typename A0>
+        struct result<This(A0)>
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, unused_type, unused_type>::value
+                  , A0, unused_type, unused_type
+                >::type
+            type;
+        };
+        template <typename This, typename A0, typename A1>
+        struct result<This(A0, A1)>
+        {
+            typedef typename
+                result_helper<
+                    detail::contains_actor<A0, A1, unused_type>::value
+                  , A0, A1, unused_type
+                >::type
+            type;
+        };
+        template <typename This, typename A0, typename A1, typename A2>
+        struct result<This(A0, A1, A2)>
+        {
+            typedef typename
+                result_helper<
+                     detail::contains_actor<A0, A1, A2>::value
+                   , A0, A1, A2
+                 >::type
+                 type;
+        };
+        template <typename A0>
+        typename result<A0>::type
+        operator()(A0 const& _0
+          , typename detail::contains_actor<A0>::is_false = 0) const
+        {
+            typedef typename result<A0>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0)
+                  , this->proto_base().child0)
+            );
+        }
+        template <typename A0, typename A1>
+        typename result<A0, A1>::type
+        operator()(A0 const& _0, A1 const& _1
+          , typename detail::contains_actor<A0, A1>::is_false = 0) const
+        {
+            typedef typename result<A0, A1>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0, _1)
+                  , this->proto_base().child0)
+            );
+        }
+        template <typename A0, typename A1, typename A2>
+        typename result<A0, A1, A2>::type
+        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+          , typename detail::contains_actor<A0, A1, A2>::is_false = 0) const
+        {
+            typedef typename result<A0, A1, A2>::type result_type;
+            typedef typename result_type::proto_child0 child_type;
+            return result_type::make(
+                child_type(
+                    detail::make_vector(_0, _1, _2)
+                  , this->proto_base().child0)
+            );
+        }
+        template <typename A0>
+        typename result<A0>::type
+        operator()(A0 const& _0
+          , typename detail::contains_actor<A0>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0));
+        }
+        template <typename A0, typename A1>
+        typename result<A0, A1>::type
+        operator()(A0 const& _0, A1 const& _1
+          , typename detail::contains_actor<A0, A1>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type
+              , typename phoenix::as_actor<A1>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0)
+              , phoenix::as_actor<A1>::convert(_1));
+        }
+        template <typename A0, typename A1, typename A2>
+        typename result<A0, A1, A2>::type
+        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+          , typename detail::contains_actor<A0, A1, A2>::is_true = 0) const
+        {
+            return make_lazy<this_type
+              , typename phoenix::as_actor<A0>::type
+              , typename phoenix::as_actor<A1>::type
+              , typename phoenix::as_actor<A2>::type>()(*this
+              , phoenix::as_actor<A0>::convert(_0)
+              , phoenix::as_actor<A1>::convert(_1)
+              , phoenix::as_actor<A2>::convert(_2));
+        }
+    private:
+        terminal& operator= (terminal const&);
+    };
+    namespace result_of
+    {
+        template <typename Tag>
+        struct terminal
+        {
+            typedef spirit::terminal<Tag> type;
+        };
+        template <typename Tag, typename A0>
+        struct terminal<Tag(A0)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0>::type type;
+        };
+        template <typename Tag, typename A0, typename A1>
+        struct terminal<Tag(A0, A1)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0, A1>::type type;
+        };
+        template <typename Tag, typename A0, typename A1, typename A2>
+        struct terminal<Tag(A0, A1, A2)>
+        {
+            typedef typename spirit::terminal<Tag>::
+                template result<A0, A1, A2>::type type;
+        };
+    }
+    namespace tag
+    {
+        template <
+            typename Data, typename Tag
+          , typename DataTag1 = unused_type, typename DataTag2 = unused_type>
+        struct stateful_tag
+        {
+            typedef Data data_type;
+            stateful_tag() {}
+            stateful_tag(data_type const& data) : data_(data) {}
+            data_type data_;
+        private:
+            stateful_tag& operator= (stateful_tag const&);
+        };
+    }
+    template <
+        typename Data, typename Tag
+      , typename DataTag1 = unused_type, typename DataTag2 = unused_type>
+    struct stateful_tag_type
+      : spirit::terminal<tag::stateful_tag<Data, Tag, DataTag1, DataTag2> >
+    {
+        typedef tag::stateful_tag<Data, Tag, DataTag1, DataTag2> tag_type;
+        stateful_tag_type() {}
+        stateful_tag_type(Data const& data)
+          : spirit::terminal<tag_type>(data)
+        {}
+    private:
+        stateful_tag_type& operator= (stateful_tag_type const&);
+    };
+    namespace detail
+    {
+        template <typename StatefulTag>
+        struct get_stateful_data
+        {
+            typedef typename StatefulTag::data_type data_type;
+            template <typename Tag_>
+            static data_type call(Tag_) { return data_type(); }
+            static data_type const& call(StatefulTag const& t) { return t.data_; }
+        };
+    }
+}}
+namespace boost { namespace spirit { namespace char_encoding
+{
+    struct standard
+    {
+        typedef char char_type;
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+        static bool
+        ischar(int ch)
+        {
+            return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false;
+        }
+        static int
+        isalnum(int ch)
+        {
+            return std::isalnum(ch);
+        }
+        static int
+        isalpha(int ch)
+        {
+            return std::isalpha(ch);
+        }
+        static int
+        isdigit(int ch)
+        {
+            return std::isdigit(ch);
+        }
+        static int
+        isxdigit(int ch)
+        {
+            return std::isxdigit(ch);
+        }
+        static int
+        iscntrl(int ch)
+        {
+            return std::iscntrl(ch);
+        }
+        static int
+        isgraph(int ch)
+        {
+            return std::isgraph(ch);
+        }
+        static int
+        islower(int ch)
+        {
+            return std::islower(ch);
+        }
+        static int
+        isprint(int ch)
+        {
+            return std::isprint(ch);
+        }
+        static int
+        ispunct(int ch)
+        {
+            return std::ispunct(ch);
+        }
+        static int
+        isspace(int ch)
+        {
+            return std::isspace(ch);
+        }
+        static int
+        isblank (int ch)
+        {
+            return (ch == ' ' || ch == '\t');
+        }
+        static int
+        isupper(int ch)
+        {
+            return std::isupper(ch);
+        }
+        static int
+        tolower(int ch)
+        {
+            return std::tolower(ch);
+        }
+        static int
+        toupper(int ch)
+        {
+            return std::toupper(ch);
+        }
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <std::size_t N>
+    struct wchar_t_size
+    {
+        struct not_supported_size_of_wchar_t; typedef struct
+ not_supported_size_of_wchar_t27
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_size_of_wchar_t::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg27
+        ; enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<(N == 1 || N == 2 || N == 4)>( mpl_assert_arg27::assert_arg() ) ) }
+                                              ;
+    };
+    template <> struct wchar_t_size<1> { enum { mask = 0xff }; };
+    template <> struct wchar_t_size<2> { enum { mask = 0xffff }; };
+    template <> struct wchar_t_size<4> { enum { mask = 0xffffffff }; };
+}}}
+namespace boost { namespace spirit { namespace char_encoding
+{
+    struct standard_wide
+    {
+        typedef wchar_t char_type;
+        template <typename Char>
+        static typename std::char_traits<Char>::int_type
+        to_int_type(Char ch)
+        {
+            return std::char_traits<Char>::to_int_type(ch);
+        }
+        template <typename Char>
+        static Char
+        to_char_type(typename std::char_traits<Char>::int_type ch)
+        {
+            return std::char_traits<Char>::to_char_type(ch);
+        }
+        static bool
+        ischar(int ch)
+        {
+            return (
+                std::size_t(0) ==
+                    std::size_t(ch & ~traits::wchar_t_size<sizeof(wchar_t)>::mask) ||
+                std::size_t(~0) ==
+                    std::size_t(ch | traits::wchar_t_size<sizeof(wchar_t)>::mask)
+            ) ? true : false;
+        }
+        static bool
+        isalnum(wchar_t ch)
+        {
+            using namespace std;
+            return iswalnum(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isalpha(wchar_t ch)
+        {
+            using namespace std;
+            return iswalpha(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        iscntrl(wchar_t ch)
+        {
+            using namespace std;
+            return iswcntrl(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isdigit(wchar_t ch)
+        {
+            using namespace std;
+            return iswdigit(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isgraph(wchar_t ch)
+        {
+            using namespace std;
+            return iswgraph(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        islower(wchar_t ch)
+        {
+            using namespace std;
+            return iswlower(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isprint(wchar_t ch)
+        {
+            using namespace std;
+            return iswprint(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        ispunct(wchar_t ch)
+        {
+            using namespace std;
+            return iswpunct(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isspace(wchar_t ch)
+        {
+            using namespace std;
+            return iswspace(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isupper(wchar_t ch)
+        {
+            using namespace std;
+            return iswupper(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isxdigit(wchar_t ch)
+        {
+            using namespace std;
+            return iswxdigit(to_int_type(ch)) ? true : false;
+        }
+        static bool
+        isblank (wchar_t ch)
+        {
+            return (ch == L' ' || ch == L'\t');
+        }
+        static wchar_t
+        tolower(wchar_t ch)
+        {
+            using namespace std;
+            return isupper(ch) ?
+                to_char_type<wchar_t>(towlower(to_int_type(ch))) : ch;
+        }
+        static wchar_t
+        toupper(wchar_t ch)
+        {
+            using namespace std;
+            return islower(ch) ?
+                to_char_type<wchar_t>(towupper(to_int_type(ch))) : ch;
+        }
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace char_encoding
+{
+    const unsigned char ascii_char_types[] =
+    {
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0040,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0008,
+    };
+    struct ascii
+    {
+        typedef char char_type;
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+        static bool
+        ischar(int ch)
+        {
+            return isascii_(ch);
+        }
+        static int
+        isalnum(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0004)
+                || (ascii_char_types[ch] & 0x0001);
+        }
+        static int
+        isalpha(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0004);
+        }
+        static int
+        isdigit(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0001);
+        }
+        static int
+        isxdigit(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0002);
+        }
+        static int
+        iscntrl(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0008);
+        }
+        static int
+        isgraph(int ch)
+        {
+            return ('\x21' <= ch && ch <= '\x7e');
+        }
+        static int
+        islower(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0010);
+        }
+        static int
+        isprint(int ch)
+        {
+            return ('\x20' <= ch && ch <= '\x7e');
+        }
+        static int
+        ispunct(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0080);
+        }
+        static int
+        isspace(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0040);
+        }
+        static int
+        isblank (int ch)
+        {
+            return ('\x09' == ch || '\x20' == ch);
+        }
+        static int
+        isupper(int ch)
+        {
+            (static_cast<void> (0));
+            return (ascii_char_types[ch] & 0x0020);
+        }
+        static int
+        tolower(int ch)
+        {
+            (static_cast<void> (0));
+            return isupper(ch) ? (ch - 'A' + 'a') : ch;
+        }
+        static int
+        toupper(int ch)
+        {
+            (static_cast<void> (0));
+            return islower(ch) ? (ch - 'a' + 'A') : ch;
+        }
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace char_encoding
+{
+    const unsigned char iso8859_1_char_types[] =
+    {
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008|0x0040,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0040,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0001|0x0002,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0002|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0002|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0008,
+                            0x0040,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0001|0x0080,
+                            0x0001|0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0001|0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0080,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0080,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0020,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0080,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+                            0x0004|0x0010,
+    };
+    const unsigned char iso8859_1_char_conversion[] =
+    {
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            'a',
+                            'b',
+                            'c',
+                            'd',
+                            'e',
+                            'f',
+                            'g',
+                            'h',
+                            'i',
+                            'j',
+                            'k',
+                            'l',
+                            'm',
+                            'n',
+                            'o',
+                            'p',
+                            'q',
+                            'r',
+                            's',
+                            't',
+                            'u',
+                            'v',
+                            'w',
+                            'x',
+                            'y',
+                            'z',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            'A',
+                            'B',
+                            'C',
+                            'D',
+                            'E',
+                            'F',
+                            'G',
+                            'H',
+                            'I',
+                            'J',
+                            'K',
+                            'L',
+                            'M',
+                            'N',
+                            'O',
+                            'P',
+                            'Q',
+                            'R',
+                            'S',
+                            'T',
+                            'U',
+                            'V',
+                            'W',
+                            'X',
+                            'Y',
+                            'Z',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            '\0',
+                            0xe0,
+                            0xe1,
+                            0xe2,
+                            0xe3,
+                            0xe4,
+                            0xe5,
+                            0xe6,
+                            0xe7,
+                            0xe8,
+                            0xe9,
+                            0xea,
+                            0xeb,
+                            0xec,
+                            0xed,
+                            0xee,
+                            0xef,
+                            0xf0,
+                            0xf1,
+                            0xf2,
+                            0xf3,
+                            0xf4,
+                            0xf5,
+                            0xf6,
+                            '\0',
+                            0xf8,
+                            0xf9,
+                            0xfa,
+                            0xfb,
+                            0xfc,
+                            0xfd,
+                            0xfe,
+                            '\0',
+                            0xc0,
+                            0xc1,
+                            0xc2,
+                            0xc3,
+                            0xc4,
+                            0xc5,
+                            0xc6,
+                            0xc7,
+                            0xc8,
+                            0xc9,
+                            0xca,
+                            0xcb,
+                            0xcc,
+                            0xcd,
+                            0xce,
+                            0xcf,
+                            0xd0,
+                            0xd1,
+                            0xd2,
+                            0xd3,
+                            0xd4,
+                            0xd5,
+                            0xd6,
+                            '\0',
+                            0xd8,
+                            0xd9,
+                            0xda,
+                            0xdb,
+                            0xdc,
+                            0xdd,
+                            0xde,
+                            '\0',
+    };
+    struct iso8859_1
+    {
+        typedef unsigned char char_type;
+        static bool
+        isascii_(int ch)
+        {
+            return 0 == (ch & ~0x7f);
+        }
+        static bool
+        ischar(int ch)
+        {
+            return (0 == (ch & ~0xff) || ~0 == (ch | 0xff)) ? true : false;
+        }
+        static int
+        isalnum(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0004)
+                || (iso8859_1_char_types[ch] & 0x0001);
+        }
+        static int
+        isalpha(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0004);
+        }
+        static int
+        isdigit(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0001);
+        }
+        static int
+        isxdigit(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0002);
+        }
+        static int
+        iscntrl(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0008);
+        }
+        static int
+        isgraph(int ch)
+        {
+            return ('\x21' <= ch && ch <= '\x7e') || ('\xa1' <= ch && ch <= '\xff');
+        }
+        static int
+        islower(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0010);
+        }
+        static int
+        isprint(int ch)
+        {
+            return ('\x20' <= ch && ch <= '\x7e') || ('\xa0' <= ch && ch <= '\xff');
+        }
+        static int
+        ispunct(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0080);
+        }
+        static int
+        isspace(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0040);
+        }
+        static int
+        isblank (int ch)
+        {
+            return ('\x09' == ch || '\x20' == ch || '\xa0' == ch);
+        }
+        static int
+        isupper(int ch)
+        {
+            (static_cast<void> (0));
+            return (iso8859_1_char_types[ch] & 0x0020);
+        }
+        static int
+        tolower(int ch)
+        {
+            return isupper(ch) && '\0' != iso8859_1_char_conversion[ch] ?
+                iso8859_1_char_conversion[ch] : ch;
+        }
+        static int
+        toupper(int ch)
+        {
+            return islower(ch) && '\0' != iso8859_1_char_conversion[ch] ?
+                iso8859_1_char_conversion[ch] : ch;
+        }
+        static ::boost::uint32_t
+        toucs4(int ch)
+        {
+            return ch;
+        }
+    };
+}}}
+namespace boost {
+namespace detail {
+template <class T>
+struct make_signed_imp
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_39;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_43;
+   typedef typename remove_cv<T>::type t_no_cv;
+   typedef typename mpl::if_c<
+      (::boost::type_traits::ice_and<
+         ::boost::is_signed<T>::value,
+         ::boost::is_integral<T>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+      T,
+      typename mpl::if_c<
+         (::boost::type_traits::ice_and<
+            ::boost::is_integral<T>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+         ::value),
+         typename mpl::if_<
+            is_same<t_no_cv, unsigned char>,
+            signed char,
+            typename mpl::if_<
+               is_same<t_no_cv, unsigned short>,
+               signed short,
+               typename mpl::if_<
+                  is_same<t_no_cv, unsigned int>,
+                  int,
+                  typename mpl::if_<
+                     is_same<t_no_cv, unsigned long>,
+                     long,
+                     boost::long_long_type
+                  >::type
+               >::type
+            >::type
+         >::type,
+         typename mpl::if_c<
+            sizeof(t_no_cv) == sizeof(unsigned char),
+            signed char,
+            typename mpl::if_c<
+               sizeof(t_no_cv) == sizeof(unsigned short),
+               signed short,
+               typename mpl::if_c<
+                  sizeof(t_no_cv) == sizeof(unsigned int),
+                  int,
+                  typename mpl::if_c<
+                     sizeof(t_no_cv) == sizeof(unsigned long),
+                     long,
+                     boost::long_long_type
+                  >::type
+               >::type
+            >::type
+         >::type
+      >::type
+   >::type base_integer_type;
+   typedef typename mpl::if_<
+      is_const<T>,
+      typename add_const<base_integer_type>::type,
+      base_integer_type
+   >::type const_base_integer_type;
+   typedef typename mpl::if_<
+      is_volatile<T>,
+      typename add_volatile<const_base_integer_type>::type,
+      const_base_integer_type
+   >::type type;
+};
+}
+template< typename T > struct make_signed { public: typedef typename boost::detail::make_signed_imp<T>::type type; };
+}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename TargetChar, typename SourceChar>
+    TargetChar cast_char(SourceChar ch)
+    {
+        if (is_signed<TargetChar>::value != is_signed<SourceChar>::value)
+        {
+            if (is_signed<SourceChar>::value)
+            {
+                typedef typename make_unsigned<SourceChar>::type USourceChar;
+                return TargetChar(USourceChar(ch));
+            }
+            else
+            {
+                typedef typename make_signed<SourceChar>::type SSourceChar;
+                return TargetChar(SSourceChar(ch));
+            }
+        }
+        else
+        {
+            return TargetChar(ch);
+        }
+    }
+}}}
+namespace boost { namespace spirit { namespace tag
+{
+    struct char_ { };
+    struct string { };
+    struct alnum { };
+    struct alpha { };
+    struct digit { };
+    struct xdigit { };
+    struct cntrl { };
+    struct graph { };
+    struct print { };
+    struct punct { };
+    struct space { };
+    struct blank { };
+    struct no_case { };
+    struct lower { };
+    struct upper { };
+    struct lowernum { };
+    struct uppernum { };
+    struct ucs4 { };
+    struct encoding { };
+    template <typename CharClass>
+    struct char_code_base {};
+    template <typename CharEncoding>
+    struct char_encoding_base {};
+    template <typename CharClass, typename CharEncoding>
+    struct char_code
+        : char_code_base<CharClass>, char_encoding_base<CharEncoding>
+    {
+        typedef CharEncoding char_encoding;
+        typedef CharClass char_class;
+    };
+}}}
+namespace boost { namespace spirit { namespace char_class
+{
+    template <typename CharEncoding>
+    struct classify
+    {
+        typedef typename CharEncoding::char_type char_type;
+        template <typename Char> static bool is(tag::char_, Char ch) { return CharEncoding::ischar (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::alnum, Char ch) { return CharEncoding::isalnum (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::alpha, Char ch) { return CharEncoding::isalpha (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::digit, Char ch) { return CharEncoding::isdigit (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::xdigit, Char ch) { return CharEncoding::isxdigit (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::cntrl, Char ch) { return CharEncoding::iscntrl (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::graph, Char ch) { return CharEncoding::isgraph (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::lower, Char ch) { return CharEncoding::islower (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::print, Char ch) { return CharEncoding::isprint (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::punct, Char ch) { return CharEncoding::ispunct (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::space, Char ch) { return CharEncoding::isspace (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::blank, Char ch) { return CharEncoding::isblank (detail::cast_char<char_type>(ch)); }
+        template <typename Char> static bool is(tag::upper, Char ch) { return CharEncoding::isupper (detail::cast_char<char_type>(ch)); }
+        template <typename Char>
+        static bool
+        is(tag::lowernum, Char ch)
+        {
+            return CharEncoding::islower(detail::cast_char<char_type>(ch)) ||
+                   CharEncoding::isdigit(detail::cast_char<char_type>(ch));
+        }
+        template <typename Char>
+        static bool
+        is(tag::uppernum, Char ch)
+        {
+            return CharEncoding::isupper(detail::cast_char<char_type>(ch)) ||
+                   CharEncoding::isdigit(detail::cast_char<char_type>(ch));
+        }
+    };
+    template <typename CharEncoding>
+    struct convert
+    {
+        typedef typename CharEncoding::char_type char_type;
+        template <typename Char>
+        static Char
+        to(tag::lower, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::tolower(detail::cast_char<char_type>(ch)));
+        }
+        template <typename Char>
+        static Char
+        to(tag::upper, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::toupper(detail::cast_char<char_type>(ch)));
+        }
+        template <typename Char>
+        static Char
+        to(tag::ucs4, Char ch)
+        {
+            return static_cast<Char>(
+                CharEncoding::toucs4(detail::cast_char<char_type>(ch)));
+        }
+        template <typename Char>
+        static Char
+        to(unused_type, Char ch)
+        {
+            return ch;
+        }
+    };
+    template <typename CharEncoding>
+    struct what
+    {
+        static char const* is(tag::char_) { return "char"; }
+        static char const* is(tag::alnum) { return "alnum"; }
+        static char const* is(tag::alpha) { return "alpha"; }
+        static char const* is(tag::digit) { return "digit"; }
+        static char const* is(tag::xdigit) { return "xdigit"; }
+        static char const* is(tag::cntrl) { return "cntrl"; }
+        static char const* is(tag::graph) { return "graph"; }
+        static char const* is(tag::lower) { return "lower"; }
+        static char const* is(tag::lowernum) { return "lowernum"; }
+        static char const* is(tag::print) { return "print"; }
+        static char const* is(tag::punct) { return "punct"; }
+        static char const* is(tag::space) { return "space"; }
+        static char const* is(tag::blank) { return "blank"; }
+        static char const* is(tag::upper) { return "upper"; }
+        static char const* is(tag::uppernum) { return "uppernum"; }
+        static char const* is(tag::ucs4) { return "ucs4"; }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Char, typename BaseChar>
+    struct mustcheck_ischar
+      : mpl::bool_<(sizeof(Char) > sizeof(BaseChar)) ? true : false> {};
+    template <typename CharParam, typename CharEncoding
+      , bool MustCheck = mustcheck_ischar<
+            CharParam, typename CharEncoding::char_type>::value>
+    struct ischar
+    {
+        static bool call(CharParam)
+        {
+            return true;
+        }
+    };
+    template <typename CharParam, typename CharEncoding>
+    struct ischar<CharParam, CharEncoding, true>
+    {
+        static bool call(CharParam const& ch)
+        {
+            return CharEncoding::ischar(int(ch));
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    typedef mpl::vector<
+            spirit::char_encoding::ascii
+          , spirit::char_encoding::iso8859_1
+          , spirit::char_encoding::standard
+          , spirit::char_encoding::standard_wide
+        >
+    char_encodings;
+    template <typename T>
+    struct is_char_encoding : mpl::false_ {};
+    template <>
+    struct is_char_encoding<spirit::char_encoding::ascii> : mpl::true_ {};
+    template <>
+    struct is_char_encoding<spirit::char_encoding::iso8859_1> : mpl::true_ {};
+    template <>
+    struct is_char_encoding<spirit::char_encoding::standard> : mpl::true_ {};
+    template <>
+    struct is_char_encoding<spirit::char_encoding::standard_wide> : mpl::true_ {};
+    template <typename Encoding>
+    struct encoding
+        : proto::terminal<tag::char_code<tag::encoding, Encoding> >::type
+    {};
+ namespace tag { struct verbatim { }; } typedef boost::proto::terminal<tag::verbatim>::type verbatim_type; verbatim_type const verbatim = {{}}; inline void silence_unused_warnings_verbatim() { (void) verbatim; } namespace tag { struct no_delimit { }; } typedef boost::proto::terminal<tag::no_delimit>::type no_delimit_type; no_delimit_type const no_delimit = {{}}; inline void silence_unused_warnings_no_delimit() { (void) no_delimit; } namespace tag { struct lexeme { }; } typedef boost::proto::terminal<tag::lexeme>::type lexeme_type; lexeme_type const lexeme = {{}}; inline void silence_unused_warnings_lexeme() { (void) lexeme; } namespace tag { struct no_skip { }; } typedef boost::proto::terminal<tag::no_skip>::type no_skip_type; no_skip_type const no_skip = {{}}; inline void silence_unused_warnings_no_skip() { (void) no_skip; } namespace tag { struct omit { }; } typedef boost::proto::terminal<tag::omit>::type omit_type; omit_type const omit = {{}}; inline void silence_unused_warnings_omit() { (void) omit; } namespace tag { struct raw { }; } typedef boost::proto::terminal<tag::raw>::type raw_type; raw_type const raw = {{}}; inline void silence_unused_warnings_raw() { (void) raw; } namespace tag { struct as_string { }; } typedef boost::proto::terminal<tag::as_string>::type as_string_type; as_string_type const as_string = {{}}; inline void silence_unused_warnings_as_string() { (void) as_string; } namespace tag { struct as_wstring { }; } typedef boost::proto::terminal<tag::as_wstring>::type as_wstring_type; as_wstring_type const as_wstring = {{}}; inline void silence_unused_warnings_as_wstring() { (void) as_wstring; } namespace tag { struct inf { }; } typedef boost::proto::terminal<tag::inf>::type inf_type; inf_type const inf = {{}}; inline void silence_unused_warnings_inf() { (void) inf; } namespace tag { struct eol { }; } typedef boost::proto::terminal<tag::eol>::type eol_type; eol_type const eol = {{}}; inline void silence_unused_warnings_eol() { (void) eol; } namespace tag { struct eoi { }; } typedef boost::proto::terminal<tag::eoi>::type eoi_type; eoi_type const eoi = {{}}; inline void silence_unused_warnings_eoi() { (void) eoi; } namespace tag { struct buffer { }; } typedef boost::proto::terminal<tag::buffer>::type buffer_type; buffer_type const buffer = {{}}; inline void silence_unused_warnings_buffer() { (void) buffer; } namespace tag { struct true_ { }; } typedef boost::proto::terminal<tag::true_>::type true_type; true_type const true_ = {{}}; inline void silence_unused_warnings_true_() { (void) true_; } namespace tag { struct false_ { }; } typedef boost::proto::terminal<tag::false_>::type false_type; false_type const false_ = {{}}; inline void silence_unused_warnings_false_() { (void) false_; } namespace tag { struct matches { }; } typedef boost::proto::terminal<tag::matches>::type matches_type; matches_type const matches = {{}}; inline void silence_unused_warnings_matches() { (void) matches; } namespace tag { struct hold { }; } typedef boost::proto::terminal<tag::hold>::type hold_type; hold_type const hold = {{}}; inline void silence_unused_warnings_hold() { (void) hold; } namespace tag { struct strict { }; } typedef boost::proto::terminal<tag::strict>::type strict_type; strict_type const strict = {{}}; inline void silence_unused_warnings_strict() { (void) strict; } namespace tag { struct relaxed { }; } typedef boost::proto::terminal<tag::relaxed>::type relaxed_type; relaxed_type const relaxed = {{}}; inline void silence_unused_warnings_relaxed() { (void) relaxed; } namespace tag { struct duplicate { }; } typedef boost::proto::terminal<tag::duplicate>::type duplicate_type; duplicate_type const duplicate = {{}}; inline void silence_unused_warnings_duplicate() { (void) duplicate; }
+ namespace tag { struct lit { }; } typedef boost::spirit::terminal<tag::lit> lit_type; lit_type const lit = lit_type(); inline void silence_unused_warnings_lit() { (void) lit; } namespace tag { struct bin { }; } typedef boost::spirit::terminal<tag::bin> bin_type; bin_type const bin = bin_type(); inline void silence_unused_warnings_bin() { (void) bin; } namespace tag { struct oct { }; } typedef boost::spirit::terminal<tag::oct> oct_type; oct_type const oct = oct_type(); inline void silence_unused_warnings_oct() { (void) oct; } namespace tag { struct hex { }; } typedef boost::spirit::terminal<tag::hex> hex_type; hex_type const hex = hex_type(); inline void silence_unused_warnings_hex() { (void) hex; } namespace tag { struct bool_ { }; } typedef boost::spirit::terminal<tag::bool_> bool_type; bool_type const bool_ = bool_type(); inline void silence_unused_warnings_bool_() { (void) bool_; } namespace tag { struct ushort_ { }; } typedef boost::spirit::terminal<tag::ushort_> ushort_type; ushort_type const ushort_ = ushort_type(); inline void silence_unused_warnings_ushort_() { (void) ushort_; } namespace tag { struct ulong_ { }; } typedef boost::spirit::terminal<tag::ulong_> ulong_type; ulong_type const ulong_ = ulong_type(); inline void silence_unused_warnings_ulong_() { (void) ulong_; } namespace tag { struct uint_ { }; } typedef boost::spirit::terminal<tag::uint_> uint_type; uint_type const uint_ = uint_type(); inline void silence_unused_warnings_uint_() { (void) uint_; } namespace tag { struct short_ { }; } typedef boost::spirit::terminal<tag::short_> short_type; short_type const short_ = short_type(); inline void silence_unused_warnings_short_() { (void) short_; } namespace tag { struct long_ { }; } typedef boost::spirit::terminal<tag::long_> long_type; long_type const long_ = long_type(); inline void silence_unused_warnings_long_() { (void) long_; } namespace tag { struct int_ { }; } typedef boost::spirit::terminal<tag::int_> int_type; int_type const int_ = int_type(); inline void silence_unused_warnings_int_() { (void) int_; } namespace tag { struct ulong_long { }; } typedef boost::spirit::terminal<tag::ulong_long> ulong_long_type; ulong_long_type const ulong_long = ulong_long_type(); inline void silence_unused_warnings_ulong_long() { (void) ulong_long; } namespace tag { struct long_long { }; } typedef boost::spirit::terminal<tag::long_long> long_long_type; long_long_type const long_long = long_long_type(); inline void silence_unused_warnings_long_long() { (void) long_long; } namespace tag { struct float_ { }; } typedef boost::spirit::terminal<tag::float_> float_type; float_type const float_ = float_type(); inline void silence_unused_warnings_float_() { (void) float_; } namespace tag { struct double_ { }; } typedef boost::spirit::terminal<tag::double_> double_type; double_type const double_ = double_type(); inline void silence_unused_warnings_double_() { (void) double_; } namespace tag { struct long_double { }; } typedef boost::spirit::terminal<tag::long_double> long_double_type; long_double_type const long_double = long_double_type(); inline void silence_unused_warnings_long_double() { (void) long_double; } namespace tag { struct repeat { }; } typedef boost::spirit::terminal<tag::repeat> repeat_type; repeat_type const repeat = repeat_type(); inline void silence_unused_warnings_repeat() { (void) repeat; } namespace tag { struct eps { }; } typedef boost::spirit::terminal<tag::eps> eps_type; eps_type const eps = eps_type(); inline void silence_unused_warnings_eps() { (void) eps; } namespace tag { struct pad { }; } typedef boost::spirit::terminal<tag::pad> pad_type; pad_type const pad = pad_type(); inline void silence_unused_warnings_pad() { (void) pad; } namespace tag { struct byte_ { }; } typedef boost::spirit::terminal<tag::byte_> byte_type; byte_type const byte_ = byte_type(); inline void silence_unused_warnings_byte_() { (void) byte_; } namespace tag { struct word { }; } typedef boost::spirit::terminal<tag::word> word_type; word_type const word = word_type(); inline void silence_unused_warnings_word() { (void) word; } namespace tag { struct big_word { }; } typedef boost::spirit::terminal<tag::big_word> big_word_type; big_word_type const big_word = big_word_type(); inline void silence_unused_warnings_big_word() { (void) big_word; } namespace tag { struct little_word { }; } typedef boost::spirit::terminal<tag::little_word> little_word_type; little_word_type const little_word = little_word_type(); inline void silence_unused_warnings_little_word() { (void) little_word; } namespace tag { struct dword { }; } typedef boost::spirit::terminal<tag::dword> dword_type; dword_type const dword = dword_type(); inline void silence_unused_warnings_dword() { (void) dword; } namespace tag { struct big_dword { }; } typedef boost::spirit::terminal<tag::big_dword> big_dword_type; big_dword_type const big_dword = big_dword_type(); inline void silence_unused_warnings_big_dword() { (void) big_dword; } namespace tag { struct little_dword { }; } typedef boost::spirit::terminal<tag::little_dword> little_dword_type; little_dword_type const little_dword = little_dword_type(); inline void silence_unused_warnings_little_dword() { (void) little_dword; } namespace tag { struct qword { }; } typedef boost::spirit::terminal<tag::qword> qword_type; qword_type const qword = qword_type(); inline void silence_unused_warnings_qword() { (void) qword; } namespace tag { struct big_qword { }; } typedef boost::spirit::terminal<tag::big_qword> big_qword_type; big_qword_type const big_qword = big_qword_type(); inline void silence_unused_warnings_big_qword() { (void) big_qword; } namespace tag { struct little_qword { }; } typedef boost::spirit::terminal<tag::little_qword> little_qword_type; little_qword_type const little_qword = little_qword_type(); inline void silence_unused_warnings_little_qword() { (void) little_qword; } namespace tag { struct bin_float { }; } typedef boost::spirit::terminal<tag::bin_float> bin_float_type; bin_float_type const bin_float = bin_float_type(); inline void silence_unused_warnings_bin_float() { (void) bin_float; } namespace tag { struct big_bin_float { }; } typedef boost::spirit::terminal<tag::big_bin_float> big_bin_float_type; big_bin_float_type const big_bin_float = big_bin_float_type(); inline void silence_unused_warnings_big_bin_float() { (void) big_bin_float; } namespace tag { struct little_bin_float { }; } typedef boost::spirit::terminal<tag::little_bin_float> little_bin_float_type; little_bin_float_type const little_bin_float = little_bin_float_type(); inline void silence_unused_warnings_little_bin_float() { (void) little_bin_float; } namespace tag { struct bin_double { }; } typedef boost::spirit::terminal<tag::bin_double> bin_double_type; bin_double_type const bin_double = bin_double_type(); inline void silence_unused_warnings_bin_double() { (void) bin_double; } namespace tag { struct big_bin_double { }; } typedef boost::spirit::terminal<tag::big_bin_double> big_bin_double_type; big_bin_double_type const big_bin_double = big_bin_double_type(); inline void silence_unused_warnings_big_bin_double() { (void) big_bin_double; } namespace tag { struct little_bin_double { }; } typedef boost::spirit::terminal<tag::little_bin_double> little_bin_double_type; little_bin_double_type const little_bin_double = little_bin_double_type(); inline void silence_unused_warnings_little_bin_double() { (void) little_bin_double; } namespace tag { struct skip { }; } typedef boost::spirit::terminal<tag::skip> skip_type; skip_type const skip = skip_type(); inline void silence_unused_warnings_skip() { (void) skip; } namespace tag { struct delimit { }; } typedef boost::spirit::terminal<tag::delimit> delimit_type; delimit_type const delimit = delimit_type(); inline void silence_unused_warnings_delimit() { (void) delimit; } namespace tag { struct stream { }; } typedef boost::spirit::terminal<tag::stream> stream_type; stream_type const stream = stream_type(); inline void silence_unused_warnings_stream() { (void) stream; } namespace tag { struct wstream { }; } typedef boost::spirit::terminal<tag::wstream> wstream_type; wstream_type const wstream = wstream_type(); inline void silence_unused_warnings_wstream() { (void) wstream; } namespace tag { struct left_align { }; } typedef boost::spirit::terminal<tag::left_align> left_align_type; left_align_type const left_align = left_align_type(); inline void silence_unused_warnings_left_align() { (void) left_align; } namespace tag { struct right_align { }; } typedef boost::spirit::terminal<tag::right_align> right_align_type; right_align_type const right_align = right_align_type(); inline void silence_unused_warnings_right_align() { (void) right_align; } namespace tag { struct center { }; } typedef boost::spirit::terminal<tag::center> center_type; center_type const center = center_type(); inline void silence_unused_warnings_center() { (void) center; } namespace tag { struct maxwidth { }; } typedef boost::spirit::terminal<tag::maxwidth> maxwidth_type; maxwidth_type const maxwidth = maxwidth_type(); inline void silence_unused_warnings_maxwidth() { (void) maxwidth; } namespace tag { struct set_state { }; } typedef boost::spirit::terminal<tag::set_state> set_state_type; set_state_type const set_state = set_state_type(); inline void silence_unused_warnings_set_state() { (void) set_state; } namespace tag { struct in_state { }; } typedef boost::spirit::terminal<tag::in_state> in_state_type; in_state_type const in_state = in_state_type(); inline void silence_unused_warnings_in_state() { (void) in_state; } namespace tag { struct token { }; } typedef boost::spirit::terminal<tag::token> token_type; token_type const token = token_type(); inline void silence_unused_warnings_token() { (void) token; } namespace tag { struct tokenid { }; } typedef boost::spirit::terminal<tag::tokenid> tokenid_type; tokenid_type const tokenid = tokenid_type(); inline void silence_unused_warnings_tokenid() { (void) tokenid; } namespace tag { struct raw_token { }; } typedef boost::spirit::terminal<tag::raw_token> raw_token_type; raw_token_type const raw_token = raw_token_type(); inline void silence_unused_warnings_raw_token() { (void) raw_token; } namespace tag { struct tokenid_mask { }; } typedef boost::spirit::terminal<tag::tokenid_mask> tokenid_mask_type; tokenid_mask_type const tokenid_mask = tokenid_mask_type(); inline void silence_unused_warnings_tokenid_mask() { (void) tokenid_mask; } namespace tag { struct attr { }; } typedef boost::spirit::terminal<tag::attr> attr_type; attr_type const attr = attr_type(); inline void silence_unused_warnings_attr() { (void) attr; } namespace tag { struct columns { }; } typedef boost::spirit::terminal<tag::columns> columns_type; columns_type const columns = columns_type(); inline void silence_unused_warnings_columns() { (void) columns; } namespace tag { struct auto_ { }; } typedef boost::spirit::terminal<tag::auto_> auto_type; auto_type const auto_ = auto_type(); inline void silence_unused_warnings_auto_() { (void) auto_; }
+    namespace tag
+    {
+        struct attr_cast { };
+        struct as { };
+    }
+}}
+namespace boost { namespace spirit { namespace tag { namespace ascii { typedef tag::char_code<tag::char_, spirit::char_encoding::ascii> char_; typedef tag::char_code<tag::string, spirit::char_encoding::ascii> string; }}}} namespace boost { namespace spirit { namespace ascii { typedef spirit::terminal<tag::ascii::char_> char_type; char_type const char_ = char_type(); inline void silence_unused_warnings_char_() { (void) char_; } typedef spirit::terminal<tag::ascii::string> string_type; string_type const string = string_type(); inline void silence_unused_warnings_string() { (void) string; } typedef proto::terminal<tag::char_code<tag::alnum, spirit::char_encoding::ascii> >::type alnum_type; alnum_type const alnum = alnum_type(); inline void silence_unused_warnings_alnum() { (void) alnum; } typedef proto::terminal<tag::char_code<tag::alpha, spirit::char_encoding::ascii> >::type alpha_type; alpha_type const alpha = alpha_type(); inline void silence_unused_warnings_alpha() { (void) alpha; } typedef proto::terminal<tag::char_code<tag::blank, spirit::char_encoding::ascii> >::type blank_type; blank_type const blank = blank_type(); inline void silence_unused_warnings_blank() { (void) blank; } typedef proto::terminal<tag::char_code<tag::cntrl, spirit::char_encoding::ascii> >::type cntrl_type; cntrl_type const cntrl = cntrl_type(); inline void silence_unused_warnings_cntrl() { (void) cntrl; } typedef proto::terminal<tag::char_code<tag::digit, spirit::char_encoding::ascii> >::type digit_type; digit_type const digit = digit_type(); inline void silence_unused_warnings_digit() { (void) digit; } typedef proto::terminal<tag::char_code<tag::graph, spirit::char_encoding::ascii> >::type graph_type; graph_type const graph = graph_type(); inline void silence_unused_warnings_graph() { (void) graph; } typedef proto::terminal<tag::char_code<tag::print, spirit::char_encoding::ascii> >::type print_type; print_type const print = print_type(); inline void silence_unused_warnings_print() { (void) print; } typedef proto::terminal<tag::char_code<tag::punct, spirit::char_encoding::ascii> >::type punct_type; punct_type const punct = punct_type(); inline void silence_unused_warnings_punct() { (void) punct; } typedef proto::terminal<tag::char_code<tag::space, spirit::char_encoding::ascii> >::type space_type; space_type const space = space_type(); inline void silence_unused_warnings_space() { (void) space; } typedef proto::terminal<tag::char_code<tag::xdigit, spirit::char_encoding::ascii> >::type xdigit_type; xdigit_type const xdigit = xdigit_type(); inline void silence_unused_warnings_xdigit() { (void) xdigit; } typedef proto::terminal<tag::char_code<tag::no_case, spirit::char_encoding::ascii> >::type no_case_type; no_case_type const no_case = no_case_type(); inline void silence_unused_warnings_no_case() { (void) no_case; } typedef proto::terminal<tag::char_code<tag::lower, spirit::char_encoding::ascii> >::type lower_type; lower_type const lower = lower_type(); inline void silence_unused_warnings_lower() { (void) lower; } typedef proto::terminal<tag::char_code<tag::upper, spirit::char_encoding::ascii> >::type upper_type; upper_type const upper = upper_type(); inline void silence_unused_warnings_upper() { (void) upper; } typedef proto::terminal<tag::char_code<tag::lowernum, spirit::char_encoding::ascii> >::type lowernum_type; lowernum_type const lowernum = lowernum_type(); inline void silence_unused_warnings_lowernum() { (void) lowernum; } typedef proto::terminal<tag::char_code<tag::uppernum, spirit::char_encoding::ascii> >::type uppernum_type; uppernum_type const uppernum = uppernum_type(); inline void silence_unused_warnings_uppernum() { (void) uppernum; } }}}
+namespace boost { namespace spirit { namespace tag { namespace iso8859_1 { typedef tag::char_code<tag::char_, spirit::char_encoding::iso8859_1> char_; typedef tag::char_code<tag::string, spirit::char_encoding::iso8859_1> string; }}}} namespace boost { namespace spirit { namespace iso8859_1 { typedef spirit::terminal<tag::iso8859_1::char_> char_type; char_type const char_ = char_type(); inline void silence_unused_warnings_char_() { (void) char_; } typedef spirit::terminal<tag::iso8859_1::string> string_type; string_type const string = string_type(); inline void silence_unused_warnings_string() { (void) string; } typedef proto::terminal<tag::char_code<tag::alnum, spirit::char_encoding::iso8859_1> >::type alnum_type; alnum_type const alnum = alnum_type(); inline void silence_unused_warnings_alnum() { (void) alnum; } typedef proto::terminal<tag::char_code<tag::alpha, spirit::char_encoding::iso8859_1> >::type alpha_type; alpha_type const alpha = alpha_type(); inline void silence_unused_warnings_alpha() { (void) alpha; } typedef proto::terminal<tag::char_code<tag::blank, spirit::char_encoding::iso8859_1> >::type blank_type; blank_type const blank = blank_type(); inline void silence_unused_warnings_blank() { (void) blank; } typedef proto::terminal<tag::char_code<tag::cntrl, spirit::char_encoding::iso8859_1> >::type cntrl_type; cntrl_type const cntrl = cntrl_type(); inline void silence_unused_warnings_cntrl() { (void) cntrl; } typedef proto::terminal<tag::char_code<tag::digit, spirit::char_encoding::iso8859_1> >::type digit_type; digit_type const digit = digit_type(); inline void silence_unused_warnings_digit() { (void) digit; } typedef proto::terminal<tag::char_code<tag::graph, spirit::char_encoding::iso8859_1> >::type graph_type; graph_type const graph = graph_type(); inline void silence_unused_warnings_graph() { (void) graph; } typedef proto::terminal<tag::char_code<tag::print, spirit::char_encoding::iso8859_1> >::type print_type; print_type const print = print_type(); inline void silence_unused_warnings_print() { (void) print; } typedef proto::terminal<tag::char_code<tag::punct, spirit::char_encoding::iso8859_1> >::type punct_type; punct_type const punct = punct_type(); inline void silence_unused_warnings_punct() { (void) punct; } typedef proto::terminal<tag::char_code<tag::space, spirit::char_encoding::iso8859_1> >::type space_type; space_type const space = space_type(); inline void silence_unused_warnings_space() { (void) space; } typedef proto::terminal<tag::char_code<tag::xdigit, spirit::char_encoding::iso8859_1> >::type xdigit_type; xdigit_type const xdigit = xdigit_type(); inline void silence_unused_warnings_xdigit() { (void) xdigit; } typedef proto::terminal<tag::char_code<tag::no_case, spirit::char_encoding::iso8859_1> >::type no_case_type; no_case_type const no_case = no_case_type(); inline void silence_unused_warnings_no_case() { (void) no_case; } typedef proto::terminal<tag::char_code<tag::lower, spirit::char_encoding::iso8859_1> >::type lower_type; lower_type const lower = lower_type(); inline void silence_unused_warnings_lower() { (void) lower; } typedef proto::terminal<tag::char_code<tag::upper, spirit::char_encoding::iso8859_1> >::type upper_type; upper_type const upper = upper_type(); inline void silence_unused_warnings_upper() { (void) upper; } typedef proto::terminal<tag::char_code<tag::lowernum, spirit::char_encoding::iso8859_1> >::type lowernum_type; lowernum_type const lowernum = lowernum_type(); inline void silence_unused_warnings_lowernum() { (void) lowernum; } typedef proto::terminal<tag::char_code<tag::uppernum, spirit::char_encoding::iso8859_1> >::type uppernum_type; uppernum_type const uppernum = uppernum_type(); inline void silence_unused_warnings_uppernum() { (void) uppernum; } }}}
+namespace boost { namespace spirit { namespace tag { namespace standard { typedef tag::char_code<tag::char_, spirit::char_encoding::standard> char_; typedef tag::char_code<tag::string, spirit::char_encoding::standard> string; }}}} namespace boost { namespace spirit { namespace standard { typedef spirit::terminal<tag::standard::char_> char_type; char_type const char_ = char_type(); inline void silence_unused_warnings_char_() { (void) char_; } typedef spirit::terminal<tag::standard::string> string_type; string_type const string = string_type(); inline void silence_unused_warnings_string() { (void) string; } typedef proto::terminal<tag::char_code<tag::alnum, spirit::char_encoding::standard> >::type alnum_type; alnum_type const alnum = alnum_type(); inline void silence_unused_warnings_alnum() { (void) alnum; } typedef proto::terminal<tag::char_code<tag::alpha, spirit::char_encoding::standard> >::type alpha_type; alpha_type const alpha = alpha_type(); inline void silence_unused_warnings_alpha() { (void) alpha; } typedef proto::terminal<tag::char_code<tag::blank, spirit::char_encoding::standard> >::type blank_type; blank_type const blank = blank_type(); inline void silence_unused_warnings_blank() { (void) blank; } typedef proto::terminal<tag::char_code<tag::cntrl, spirit::char_encoding::standard> >::type cntrl_type; cntrl_type const cntrl = cntrl_type(); inline void silence_unused_warnings_cntrl() { (void) cntrl; } typedef proto::terminal<tag::char_code<tag::digit, spirit::char_encoding::standard> >::type digit_type; digit_type const digit = digit_type(); inline void silence_unused_warnings_digit() { (void) digit; } typedef proto::terminal<tag::char_code<tag::graph, spirit::char_encoding::standard> >::type graph_type; graph_type const graph = graph_type(); inline void silence_unused_warnings_graph() { (void) graph; } typedef proto::terminal<tag::char_code<tag::print, spirit::char_encoding::standard> >::type print_type; print_type const print = print_type(); inline void silence_unused_warnings_print() { (void) print; } typedef proto::terminal<tag::char_code<tag::punct, spirit::char_encoding::standard> >::type punct_type; punct_type const punct = punct_type(); inline void silence_unused_warnings_punct() { (void) punct; } typedef proto::terminal<tag::char_code<tag::space, spirit::char_encoding::standard> >::type space_type; space_type const space = space_type(); inline void silence_unused_warnings_space() { (void) space; } typedef proto::terminal<tag::char_code<tag::xdigit, spirit::char_encoding::standard> >::type xdigit_type; xdigit_type const xdigit = xdigit_type(); inline void silence_unused_warnings_xdigit() { (void) xdigit; } typedef proto::terminal<tag::char_code<tag::no_case, spirit::char_encoding::standard> >::type no_case_type; no_case_type const no_case = no_case_type(); inline void silence_unused_warnings_no_case() { (void) no_case; } typedef proto::terminal<tag::char_code<tag::lower, spirit::char_encoding::standard> >::type lower_type; lower_type const lower = lower_type(); inline void silence_unused_warnings_lower() { (void) lower; } typedef proto::terminal<tag::char_code<tag::upper, spirit::char_encoding::standard> >::type upper_type; upper_type const upper = upper_type(); inline void silence_unused_warnings_upper() { (void) upper; } typedef proto::terminal<tag::char_code<tag::lowernum, spirit::char_encoding::standard> >::type lowernum_type; lowernum_type const lowernum = lowernum_type(); inline void silence_unused_warnings_lowernum() { (void) lowernum; } typedef proto::terminal<tag::char_code<tag::uppernum, spirit::char_encoding::standard> >::type uppernum_type; uppernum_type const uppernum = uppernum_type(); inline void silence_unused_warnings_uppernum() { (void) uppernum; } }}}
+namespace boost { namespace spirit { namespace tag { namespace standard_wide { typedef tag::char_code<tag::char_, spirit::char_encoding::standard_wide> char_; typedef tag::char_code<tag::string, spirit::char_encoding::standard_wide> string; }}}} namespace boost { namespace spirit { namespace standard_wide { typedef spirit::terminal<tag::standard_wide::char_> char_type; char_type const char_ = char_type(); inline void silence_unused_warnings_char_() { (void) char_; } typedef spirit::terminal<tag::standard_wide::string> string_type; string_type const string = string_type(); inline void silence_unused_warnings_string() { (void) string; } typedef proto::terminal<tag::char_code<tag::alnum, spirit::char_encoding::standard_wide> >::type alnum_type; alnum_type const alnum = alnum_type(); inline void silence_unused_warnings_alnum() { (void) alnum; } typedef proto::terminal<tag::char_code<tag::alpha, spirit::char_encoding::standard_wide> >::type alpha_type; alpha_type const alpha = alpha_type(); inline void silence_unused_warnings_alpha() { (void) alpha; } typedef proto::terminal<tag::char_code<tag::blank, spirit::char_encoding::standard_wide> >::type blank_type; blank_type const blank = blank_type(); inline void silence_unused_warnings_blank() { (void) blank; } typedef proto::terminal<tag::char_code<tag::cntrl, spirit::char_encoding::standard_wide> >::type cntrl_type; cntrl_type const cntrl = cntrl_type(); inline void silence_unused_warnings_cntrl() { (void) cntrl; } typedef proto::terminal<tag::char_code<tag::digit, spirit::char_encoding::standard_wide> >::type digit_type; digit_type const digit = digit_type(); inline void silence_unused_warnings_digit() { (void) digit; } typedef proto::terminal<tag::char_code<tag::graph, spirit::char_encoding::standard_wide> >::type graph_type; graph_type const graph = graph_type(); inline void silence_unused_warnings_graph() { (void) graph; } typedef proto::terminal<tag::char_code<tag::print, spirit::char_encoding::standard_wide> >::type print_type; print_type const print = print_type(); inline void silence_unused_warnings_print() { (void) print; } typedef proto::terminal<tag::char_code<tag::punct, spirit::char_encoding::standard_wide> >::type punct_type; punct_type const punct = punct_type(); inline void silence_unused_warnings_punct() { (void) punct; } typedef proto::terminal<tag::char_code<tag::space, spirit::char_encoding::standard_wide> >::type space_type; space_type const space = space_type(); inline void silence_unused_warnings_space() { (void) space; } typedef proto::terminal<tag::char_code<tag::xdigit, spirit::char_encoding::standard_wide> >::type xdigit_type; xdigit_type const xdigit = xdigit_type(); inline void silence_unused_warnings_xdigit() { (void) xdigit; } typedef proto::terminal<tag::char_code<tag::no_case, spirit::char_encoding::standard_wide> >::type no_case_type; no_case_type const no_case = no_case_type(); inline void silence_unused_warnings_no_case() { (void) no_case; } typedef proto::terminal<tag::char_code<tag::lower, spirit::char_encoding::standard_wide> >::type lower_type; lower_type const lower = lower_type(); inline void silence_unused_warnings_lower() { (void) lower; } typedef proto::terminal<tag::char_code<tag::upper, spirit::char_encoding::standard_wide> >::type upper_type; upper_type const upper = upper_type(); inline void silence_unused_warnings_upper() { (void) upper; } typedef proto::terminal<tag::char_code<tag::lowernum, spirit::char_encoding::standard_wide> >::type lowernum_type; lowernum_type const lowernum = lowernum_type(); inline void silence_unused_warnings_lowernum() { (void) lowernum; } typedef proto::terminal<tag::char_code<tag::uppernum, spirit::char_encoding::standard_wide> >::type uppernum_type; uppernum_type const uppernum = uppernum_type(); inline void silence_unused_warnings_uppernum() { (void) uppernum; } }}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Char>
+    struct char_encoding_from_char;
+    template <>
+    struct char_encoding_from_char<char>
+      : mpl::identity<spirit::char_encoding::standard>
+    {};
+    template <>
+    struct char_encoding_from_char<wchar_t>
+      : mpl::identity<spirit::char_encoding::standard_wide>
+    {};
+    template <typename T>
+    struct char_encoding_from_char<T const>
+      : char_encoding_from_char<T>
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Skipper>
+    struct unused_skipper : unused_type
+    {
+        unused_skipper(Skipper const& skipper)
+          : skipper(skipper) {}
+        Skipper const& skipper;
+    private:
+        unused_skipper& operator= (unused_skipper const&);
+    };
+    template <typename Skipper>
+    inline Skipper const&
+    get_skipper(unused_skipper<Skipper> const& u)
+    {
+        return u.skipper;
+    }
+    template <typename Skipper>
+    inline Skipper const&
+    get_skipper(Skipper const& u)
+    {
+        return u;
+    }
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename T>
+    inline void skip_over(Iterator& first, Iterator const& last, T const& skipper)
+    {
+        while (first != last && skipper.parse(first, last, unused, unused, unused))
+                 ;
+    }
+    template <typename Iterator>
+    inline void skip_over(Iterator&, Iterator const&, unused_type)
+    {
+    }
+    template <typename Iterator, typename Skipper>
+    inline void skip_over(Iterator&, Iterator const&
+      , detail::unused_skipper<Skipper> const&)
+    {
+    }
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Domain, typename T, typename Enable = void>
+    struct meta_create;
+    template <typename Domain, typename T, typename Enable = void>
+    struct meta_create_exists : mpl::false_ {};
+}}}
+namespace boost { namespace spirit
+{
+    namespace detail
+    {
+        template <typename T>
+        struct add_const_ref
+          : add_reference<typename add_const<T>::type> {};
+        template <typename T>
+        struct remove_const_ref
+          : remove_const<typename remove_reference<T>::type> {};
+        template <typename OpTag, typename Domain>
+        struct nary_proto_expr_function
+        {
+            template <typename T>
+            struct result;
+            template <typename T1, typename T2>
+            struct result<nary_proto_expr_function(T1, T2)>
+            {
+                typedef typename remove_const_ref<T1>::type left_type;
+                typedef typename
+                    spirit::traits::meta_create<Domain, T2>::type
+                right_type;
+                typedef typename mpl::eval_if<
+                    traits::not_is_unused<left_type>
+                  , proto::result_of::make_expr<OpTag, left_type, right_type>
+                  , mpl::identity<right_type>
+                >::type type;
+            };
+            template <typename T>
+            typename result<nary_proto_expr_function(unused_type const&, T)>::type
+            operator()(unused_type const&, T) const
+            {
+                typedef spirit::traits::meta_create<Domain, T> right_type;
+                return right_type::call();
+            }
+            template <typename T1, typename T2>
+            typename result<nary_proto_expr_function(T1, T2)>::type
+            operator()(T1 const& t1, T2) const
+            {
+                typedef spirit::traits::meta_create<Domain, T2> right_type;
+                return proto::make_expr<OpTag>(t1, right_type::call());
+            }
+        };
+    }
+    template <typename T, typename OpTag, typename Domain>
+    struct make_unary_proto_expr
+    {
+        typedef spirit::traits::meta_create<Domain, T> subject_type;
+        typedef typename proto::result_of::make_expr<
+            OpTag, typename subject_type::type
+        >::type type;
+        static type call()
+        {
+            return proto::make_expr<OpTag>(subject_type::call());
+        }
+    };
+    template <typename Sequence, typename OpTag, typename Domain>
+    struct make_nary_proto_expr
+    {
+        typedef detail::nary_proto_expr_function<OpTag, Domain>
+            make_proto_expr;
+        typedef typename fusion::result_of::fold<
+            Sequence, unused_type, make_proto_expr
+        >::type type;
+        static type call()
+        {
+            return fusion::fold(Sequence(), unused, make_proto_expr());
+        }
+    };
+    namespace detail
+    {
+        template <typename T>
+        struct is_fusion_sequence_but_not_proto_expr
+          : mpl::and_<
+                fusion::traits::is_sequence<T>
+              , mpl::not_<proto::is_expr<T> > >
+        {};
+    }
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Container>
+    struct meta_create_container
+    {
+        typedef make_unary_proto_expr<
+            typename Container::value_type
+          , proto::tag::dereference, qi::domain
+        > make_proto_expr;
+        typedef typename make_proto_expr::type type;
+        static type call()
+        {
+            return make_proto_expr::call();
+        }
+    };
+    template <typename Sequence>
+    struct meta_create_sequence
+    {
+        typedef typename mpl::fold<
+            typename fusion::result_of::as_vector<Sequence>::type
+          , mpl::vector<>, mpl::push_back<mpl::_, mpl::_>
+        >::type sequence_type;
+        typedef make_nary_proto_expr<
+            sequence_type, proto::tag::shift_right, qi::domain
+        > make_proto_expr;
+        typedef typename make_proto_expr::type type;
+        static type call()
+        {
+            return make_proto_expr::call();
+        }
+    };
+    struct no_auto_mapping_exists {};
+    template <typename T, typename Enable = void>
+    struct meta_create_impl : mpl::identity<no_auto_mapping_exists> {};
+    template <typename T>
+    struct meta_create_impl<T
+          , typename enable_if<mpl::and_<
+                traits::is_container<T>, mpl::not_<traits::is_string<T> > >
+            >::type>
+      : meta_create_container<T> {};
+    template <typename T>
+    struct meta_create_impl<T, typename enable_if<
+                spirit::detail::is_fusion_sequence_but_not_proto_expr<T>
+            >::type>
+      : meta_create_sequence<T> {};
+    template <typename T, typename Enable = void>
+    struct meta_create : meta_create_impl<T> {};
+    template <typename T>
+    struct meta_create<boost::optional<T> >
+    {
+        typedef make_unary_proto_expr<
+            T, proto::tag::negate, qi::domain
+        > make_proto_expr;
+        typedef typename make_proto_expr::type type;
+        static type call()
+        {
+            return make_proto_expr::call();
+        }
+    };
+    template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct meta_create<boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19> >
+    {
+        typedef make_nary_proto_expr<
+            typename boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>::types
+          , proto::tag::bitwise_or, qi::domain
+        > make_proto_expr;
+        typedef typename make_proto_expr::type type;
+        static type call()
+        {
+            return make_proto_expr::call();
+        }
+    };
+    template <>
+    struct meta_create<char>
+    {
+        typedef spirit::standard::char_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<signed char>
+    {
+        typedef spirit::standard::char_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<wchar_t>
+    {
+        typedef spirit::standard_wide::char_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<unsigned char>
+    {
+        typedef spirit::standard::char_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<bool>
+    {
+        typedef spirit::bool_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<int>
+    {
+        typedef spirit::int_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<short>
+    {
+        typedef spirit::short_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<long>
+    {
+        typedef spirit::long_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<unsigned int>
+    {
+        typedef spirit::uint_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<unsigned short>
+    {
+        typedef spirit::ushort_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<unsigned long>
+    {
+        typedef spirit::ulong_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<boost::long_long_type>
+    {
+        typedef spirit::long_long_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<boost::ulong_long_type>
+    {
+        typedef spirit::ulong_long_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<float>
+    {
+        typedef spirit::float_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<double>
+    {
+        typedef spirit::double_type type;
+        static type call() { return type(); }
+    };
+    template <>
+    struct meta_create<long double>
+    {
+        typedef spirit::long_double_type type;
+        static type call() { return type(); }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Enable = void>
+    struct create_parser : qi::meta_create<T> {};
+    template <typename T>
+    struct meta_create<qi::domain, T>
+      : create_parser<typename spirit::detail::remove_const_ref<T>::type> {};
+    template <typename T>
+    struct meta_create_exists<qi::domain, T>
+      : mpl::not_<is_same<
+            qi::no_auto_mapping_exists
+          , typename meta_create<qi::domain, T>::type
+        > > {};
+}}}
+namespace boost { namespace spirit { namespace result_of
+{
+    template <typename T>
+    struct create_parser
+      : spirit::traits::meta_create<qi::domain, T> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename T>
+    typename result_of::create_parser<T>::type
+    create_parser()
+    {
+        return spirit::traits::meta_create<qi::domain, T>::call();
+    }
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T>
+    struct create_parser_exists
+      : meta_create_exists<qi::domain, T> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_terminal<qi::domain, tag::auto_>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::auto_;
+    using spirit::auto_type;
+    template <typename Modifiers>
+    struct auto_parser
+      : parser<auto_parser<Modifiers> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef spirit::hold_any type;
+        };
+        auto_parser(Modifiers const& modifiers)
+          : modifiers_(modifiers) {}
+        template <typename Iterator, typename Context, typename Skipper
+          , typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            return compile<qi::domain>(create_parser<Attribute>(), modifiers_)
+                      .parse(first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("auto_");
+        }
+        Modifiers modifiers_;
+    };
+    template <typename Modifiers>
+    struct make_primitive<tag::auto_, Modifiers>
+    {
+        typedef auto_parser<Modifiers> result_type;
+        result_type operator()(unused_type, Modifiers const& modifiers) const
+        {
+            return result_type(modifiers);
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <
+ typename T0 = mpl::na , typename T1 = mpl::na , typename T2 = mpl::na , typename T3 = mpl::na , typename T4 = mpl::na , typename T5 = mpl::na , typename T6 = mpl::na , typename T7 = mpl::na , typename T8 = mpl::na , typename T9 = mpl::na
+    >
+    struct locals
+      : mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> {};
+    namespace detail
+    {
+        template <typename T>
+        struct is_locals
+          : mpl::false_
+        {};
+        template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct is_locals<locals< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> >
+          : mpl::true_
+        {};
+    }
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    struct skip_flag { enum enum_type
+    {
+        postskip,
+        dont_postskip
+    };
+    };
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Expr, typename Enable = void>
+    struct parse_impl
+    {
+        struct error_invalid_expression; typedef struct error_invalid_expression32 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg32; enum { mpl_assertion_in_line_32 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg32::assert_arg() ) ) };
+    };
+    template <typename Expr>
+    struct parse_impl<Expr
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        template <typename Iterator>
+        static bool call(
+            Iterator& first
+          , Iterator last
+          , Expr const& expr)
+        {
+            return compile<qi::domain>(expr).parse(
+                first, last, unused, unused, unused);
+        }
+    };
+    template <typename Expr, typename Enable = void>
+    struct phrase_parse_impl
+    {
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+    };
+    template <typename Expr>
+    struct phrase_parse_impl<Expr
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        template <typename Iterator, typename Skipper>
+        static bool call(
+            Iterator& first
+          , Iterator last
+          , Expr const& expr
+          , Skipper const& skipper
+          , skip_flag::enum_type post_skip)
+        {
+            struct error_invalid_expression; typedef struct error_invalid_expression77 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg77; enum { mpl_assertion_in_line_77 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg77::assert_arg() ) ) };
+            typedef
+                typename result_of::compile<qi::domain, Skipper>::type
+            skipper_type;
+            skipper_type const skipper_ = compile<qi::domain>(skipper);
+            if (!compile<qi::domain>(expr).parse(
+                    first, last, unused, skipper_, unused))
+                return false;
+            if (post_skip == skip_flag::postskip)
+                qi::skip_over(first, last, skipper_);
+            return true;
+        }
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check34;
+        return detail::parse_impl<Expr>::call(first, last, expr);
+    }
+    template <typename Iterator, typename Expr>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr);
+    }
+    namespace detail
+    {
+        template <typename T>
+        struct make_context
+        {
+            typedef context<fusion::cons<T&>, locals<> > type;
+        };
+        template <>
+        struct make_context<unused_type>
+        {
+            typedef unused_type type;
+        };
+    }
+    template <typename Iterator, typename Expr, typename Attr>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Attr& attr)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check78;
+        struct error_invalid_expression; typedef struct error_invalid_expression83 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg83; enum { mpl_assertion_in_line_83 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg83::assert_arg() ) ) };
+        typename detail::make_context<Attr>::type context(attr);
+        return compile<qi::domain>(expr).parse(first, last, context, unused, attr);
+    }
+    template <typename Iterator, typename Expr, typename Attr>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr);
+    }
+    template <typename Iterator, typename Expr, typename Skipper>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip = skip_flag::postskip)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check115;
+        return detail::phrase_parse_impl<Expr>::call(
+            first, last, expr, skipper, post_skip);
+    }
+    template <typename Iterator, typename Expr, typename Skipper>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip = skip_flag::postskip)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip);
+    }
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , Attr& attr)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check149;
+        struct error_invalid_expression; typedef struct error_invalid_expression155 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg155; enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg155::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression156 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg156; enum { mpl_assertion_in_line_156 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg156::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typename detail::make_context<Attr>::type context(attr);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, context, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip, attr);
+    }
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , Attr& attr)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip, attr);
+    }
+    template <typename Iterator, typename Expr, typename Skipper, typename Attr>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , Attr& attr)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip, attr);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Expr>
+    struct parse_impl<Expr
+      , typename enable_if<
+            mpl::and_<
+                traits::meta_create_exists<qi::domain, Expr>
+              , mpl::not_<traits::matches<qi::domain, Expr> > >
+        >::type>
+    {
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, Expr& expr)
+        {
+            return qi::parse(first, last, create_parser<Expr>(), expr);
+        }
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, Expr const& expr)
+        {
+            return qi::parse(first, last, create_parser<Expr>()
+              , const_cast<Expr&>(expr));
+        }
+    };
+    template <>
+    struct parse_impl<char>
+    {
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, char& expr)
+        {
+            return qi::parse(first, last, create_parser<char>(), expr);
+        }
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, char const&)
+        {
+            return qi::parse(first, last, create_parser<char>());
+        }
+    };
+    template <>
+    struct parse_impl<wchar_t>
+    {
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, wchar_t& expr)
+        {
+            return qi::parse(first, last, create_parser<wchar_t>(), expr);
+        }
+        template <typename Iterator>
+        static bool call(Iterator& first, Iterator last, wchar_t const&)
+        {
+            return qi::parse(first, last, create_parser<wchar_t>());
+        }
+    };
+    template <typename Expr>
+    struct phrase_parse_impl<Expr
+      , typename enable_if<
+            mpl::and_<
+                traits::meta_create_exists<qi::domain, Expr>
+              , mpl::not_<traits::matches<qi::domain, Expr> > >
+        >::type>
+    {
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, Expr& expr
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<Expr>()
+              , skipper, post_skip, expr);
+        }
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, Expr const& expr
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<Expr>()
+              , skipper, post_skip, const_cast<Expr&>(expr));
+        }
+    };
+    template <>
+    struct phrase_parse_impl<char>
+    {
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, char& expr
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<char>()
+              , skipper, post_skip, expr);
+        }
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, char const&
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<char>()
+              , skipper, post_skip);
+        }
+    };
+    template <>
+    struct phrase_parse_impl<wchar_t>
+    {
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, wchar_t& expr
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<wchar_t>()
+              , skipper, post_skip, expr);
+        }
+        template <typename Iterator, typename Skipper>
+        static bool call(Iterator& first, Iterator last, wchar_t const&
+          , Skipper const& skipper, skip_flag::enum_type post_skip)
+        {
+            return qi::phrase_parse(first, last, create_parser<wchar_t>()
+              , skipper, post_skip);
+        }
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr& expr)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check164;
+        return detail::parse_impl<Expr>::call(first, last, expr);
+    }
+    template <typename Iterator, typename Expr, typename Skipper>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip = skip_flag::postskip)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check183;
+        return detail::phrase_parse_impl<Expr>::call(
+            first, last, expr, skipper, post_skip);
+    }
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_terminal<qi::domain, tag::eps>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::eps, fusion::vector1<A0> >
+    > : is_convertible<A0, bool> {};
+    template <>
+    struct use_lazy_terminal<
+        qi::domain, tag::eps, 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::eps;
+    using spirit::eps_type;
+    struct eps_parser : primitive_parser<eps_parser>
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& ) const
+        {
+            qi::skip_over(first, last, skipper);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("eps");
+        }
+    };
+    struct semantic_predicate : primitive_parser<semantic_predicate>
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        semantic_predicate(bool predicate)
+          : predicate(predicate) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& ) const
+        {
+            qi::skip_over(first, last, skipper);
+            return predicate;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("semantic-predicate");
+        }
+        bool predicate;
+    };
+    template <typename Modifiers>
+    struct make_primitive<tag::eps, Modifiers>
+    {
+        typedef eps_parser result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::eps, fusion::vector1<A0> >
+      , Modifiers>
+    {
+        typedef semantic_predicate result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args) ? true : false);
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Eval>
+    typename proto::terminal<phoenix::actor<Eval> >::type
+    lazy(phoenix::actor<Eval> const& f)
+    {
+        return proto::terminal<phoenix::actor<Eval> >::type::make(f);
+    }
+    namespace tag
+    {
+        struct lazy_eval
+        {
+        };
+    }
+    template <typename Domain>
+    struct is_modifier_directive<Domain, tag::lazy_eval>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit
+{
+    template <typename Eval>
+    struct use_terminal<qi::domain, phoenix::actor<Eval> >
+        : mpl::true_ {};
+    template <typename Terminal, typename Actor, int Arity>
+    struct lazy_terminal;
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::lazy;
+    typedef modify<qi::domain> qi_modify;
+    namespace detail
+    {
+        template <typename Parser, typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool lazy_parse_impl(Parser const& p
+          , Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr, mpl::false_)
+        {
+            return p.parse(first, last, context, skipper, attr);
+        }
+        template <typename Parser, typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool lazy_parse_impl(Parser const& p
+          , Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr, mpl::true_)
+        {
+            return p.parse(first, last, context, skipper, unused);
+        }
+        template <typename Parser, typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool lazy_parse_impl_main(Parser const& p
+          , Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr)
+        {
+            typedef typename traits::has_semantic_action<Parser>::type auto_rule;
+            return lazy_parse_impl(p, first, last, context, skipper, attr, auto_rule());
+        }
+    }
+    template <typename Function, typename Modifiers>
+    struct lazy_parser : parser<lazy_parser<Function, Modifiers> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                boost::result_of<qi_modify(tag::lazy_eval, Modifiers)>::type
+            modifier;
+            typedef typename
+                remove_reference<
+                    typename boost::result_of<Function(unused_type, Context)>::type
+                >::type
+            expr_type;
+            struct error_invalid_expression; typedef struct error_invalid_expression103 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (expr_type) { return 0; } } mpl_assert_arg103; enum { mpl_assertion_in_line_103 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, expr_type>::value ))>( mpl_assert_arg103::assert_arg() ) ) };
+            typedef typename
+                result_of::compile<qi::domain, expr_type, modifier>::type
+            parser_type;
+            typedef typename
+                traits::attribute_of<parser_type, Context, Iterator>::type
+            type;
+        };
+        lazy_parser(Function const& function, Modifiers const& modifiers)
+          : function(function), modifiers(modifiers) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return detail::lazy_parse_impl_main(
+                  compile<qi::domain>(function(unused, context)
+                , qi_modify()(tag::lazy_eval(), modifiers))
+                , first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("lazy"
+              , compile<qi::domain>(function(unused, context)
+                , qi_modify()(tag::lazy_eval(), modifiers))
+                    .what(context)
+            );
+        }
+        Function function;
+        Modifiers modifiers;
+    };
+    template <typename Function, typename Subject, typename Modifiers>
+    struct lazy_directive
+        : unary_parser<lazy_directive<Function, Subject, Modifiers> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                boost::result_of<qi_modify(tag::lazy_eval, Modifiers)>::type
+            modifier;
+            typedef typename
+                remove_reference<
+                    typename boost::result_of<Function(unused_type, Context)>::type
+                >::type
+            directive_expr_type;
+            typedef typename
+                proto::result_of::make_expr<
+                    proto::tag::subscript
+                  , directive_expr_type
+                  , Subject
+                >::type
+            expr_type;
+            struct error_invalid_expression; typedef struct error_invalid_expression174 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (expr_type) { return 0; } } mpl_assert_arg174; enum { mpl_assertion_in_line_174 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, expr_type>::value ))>( mpl_assert_arg174::assert_arg() ) ) };
+            typedef typename
+                result_of::compile<qi::domain, expr_type, modifier>::type
+            parser_type;
+            typedef typename
+                traits::attribute_of<parser_type, Context, Iterator>::type
+            type;
+        };
+        lazy_directive(
+            Function const& function
+          , Subject const& subject
+          , Modifiers const& modifiers)
+          : function(function), subject(subject), modifiers(modifiers) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return detail::lazy_parse_impl_main(compile<qi::domain>(
+                proto::make_expr<proto::tag::subscript>(
+                    function(unused, context)
+                  , subject)
+                , qi_modify()(tag::lazy_eval(), modifiers))
+                , first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("lazy-directive"
+              , compile<qi::domain>(
+                    proto::make_expr<proto::tag::subscript>(
+                        function(unused, context)
+                      , subject
+                    ), qi_modify()(tag::lazy_eval(), modifiers))
+                    .what(context)
+            );
+        }
+        Function function;
+        Subject subject;
+        Modifiers modifiers;
+    };
+    template <typename Eval, typename Modifiers>
+    struct make_primitive<phoenix::actor<Eval>, Modifiers>
+    {
+        typedef lazy_parser<phoenix::actor<Eval>, Modifiers> result_type;
+        result_type operator()(phoenix::actor<Eval> const& f
+          , Modifiers const& modifiers) const
+        {
+            return result_type(f, modifiers);
+        }
+    };
+    template <typename Terminal, typename Actor, int Arity, typename Modifiers>
+    struct make_primitive<lazy_terminal<Terminal, Actor, Arity>, Modifiers>
+    {
+        typedef lazy_parser<Actor, Modifiers> result_type;
+        result_type operator()(
+            lazy_terminal<Terminal, Actor, Arity> const& lt
+          , Modifiers const& modifiers) const
+        {
+            return result_type(lt.actor, modifiers);
+        }
+    };
+    template <typename Terminal, typename Actor, int Arity, typename Subject, typename Modifiers>
+    struct make_directive<lazy_terminal<Terminal, Actor, Arity>, Subject, Modifiers>
+    {
+        typedef lazy_directive<Actor, Subject, Modifiers> result_type;
+        result_type operator()(
+            lazy_terminal<Terminal, Actor, Arity> const& lt
+          , Subject const& subject, Modifiers const& modifiers) const
+        {
+            return result_type(lt.actor, subject, modifiers);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Actor, typename Modifiers, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<
+        qi::lazy_parser<Actor, Modifiers>, Attribute, Context, Iterator>
+      : handles_container<
+          typename qi::lazy_parser<Actor, Modifiers>::template
+              attribute<Context, Iterator>::parser_type
+        , Attribute, Context, Iterator>
+    {};
+    template <typename Subject, typename Actor, typename Modifiers
+      , typename Attribute, typename Context, typename Iterator>
+    struct handles_container<
+        qi::lazy_directive<Actor, Subject, Modifiers>, Attribute
+      , Context, Iterator>
+      : handles_container<
+          typename qi::lazy_directive<Actor, Subject, Modifiers>::template
+              attribute<Context, Iterator>::parser_type
+        , Attribute, Context, Iterator>
+    {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_terminal<qi::domain, tag::eol>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::eol;
+    using spirit::eol_type;
+    struct eol_parser : primitive_parser<eol_parser>
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& ) const
+        {
+            qi::skip_over(first, last, skipper);
+            Iterator it = first;
+            bool matched = false;
+            if (it != last && *it == '\r')
+            {
+                matched = true;
+                ++it;
+            }
+            if (it != last && *it == '\n')
+            {
+                matched = true;
+                ++it;
+            }
+            if (!matched)
+                return false;
+            first = it;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("eol");
+        }
+    };
+    template <typename Modifiers>
+    struct make_primitive<tag::eol, Modifiers>
+    {
+        typedef eol_parser result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_terminal<qi::domain, tag::eoi>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::eoi;
+    using spirit::eoi_type;
+    struct eoi_parser : primitive_parser<eoi_parser>
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& ) const
+        {
+            qi::skip_over(first, last, skipper);
+            return first == last;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("eoi");
+        }
+    };
+    template <typename Modifiers>
+    struct make_primitive<tag::eoi, Modifiers>
+    {
+        typedef eoi_parser result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, char& attr)
+        {
+            attr = *first;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<signed char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, signed char& attr)
+        {
+            attr = *first;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned char, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, unsigned char& attr)
+        {
+            attr = *first;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<wchar_t, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, wchar_t& attr)
+        {
+            attr = *first;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned short, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const&, unsigned short& attr)
+        {
+            attr = *first;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<bool, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, bool& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, bool_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<short, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, short& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, short_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<int, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, int& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, int_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned int, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, unsigned int& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, uint_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<unsigned long, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, unsigned long& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, ulong_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long_long_type, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long_long_type& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_long_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<ulong_long_type, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, ulong_long_type& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, ulong_long_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<float, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, float& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, float_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<double, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, double& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, double_type(), attr);
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<long double, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, long double& attr)
+        {
+            Iterator first_ = first;
+            qi::parse(first_, last, long_double_type(), attr);
+        }
+    };
+}}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Seq1, typename Seq2, bool same_size>
+    struct sequence_equal_to
+    {
+        typedef typename result_of::end<Seq1>::type end1_type;
+        typedef typename result_of::end<Seq2>::type end2_type;
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const&, I2 const&, mpl::true_)
+        {
+            return true;
+        }
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b, mpl::false_)
+        {
+            return *a == *b
+                && call(fusion::next(a), fusion::next(b));
+        }
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& a, I2 const& b)
+        {
+            typename result_of::equal_to<I1, end1_type>::type eq;
+            return call(a, b, eq);
+        }
+    };
+    template <typename Seq1, typename Seq2>
+    struct sequence_equal_to<Seq1, Seq2, false>
+    {
+        template <typename I1, typename I2>
+        static bool
+        call(I1 const& , I2 const& )
+        {
+            return false;
+        }
+    };
+}}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Seq1, typename Seq2>
+        struct sequence_copy
+        {
+            typedef typename result_of::end<Seq1>::type end1_type;
+            typedef typename result_of::end<Seq2>::type end2_type;
+            template <typename I1, typename I2>
+            static void
+            call(I1 const&, I2 const&, mpl::true_)
+            {
+            }
+            template <typename I1, typename I2>
+            static void
+            call(I1 const& src, I2 const& dest, mpl::false_)
+            {
+                *dest = *src;
+                call(fusion::next(src), fusion::next(dest));
+            }
+            template <typename I1, typename I2>
+            static void
+            call(I1 const& src, I2 const& dest)
+            {
+                typename result_of::equal_to<I1, end1_type>::type eq;
+                return call(src, dest, eq);
+            }
+        };
+    }
+    template <typename Seq1, typename Seq2>
+    inline void
+    copy(Seq1 const& src, Seq2& dest)
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((result_of::size<Seq1>::value == result_of::size<Seq2>::value) == 0 ? false : true) >)>
+ boost_static_assert_typedef_61;
+        detail::sequence_copy<
+            Seq1 const, Seq2>::
+            call(fusion::begin(src), fusion::begin(dest));
+    }
+}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Attribute, typename Iterator, typename Enable>
+    struct assign_to_attribute_from_iterators
+    {
+        static void
+        call(Iterator const& first, Iterator const& last, Attribute& attr)
+        {
+            if (traits::is_empty(attr))
+                attr = Attribute(first, last);
+            else {
+                for (Iterator i = first; i != last; ++i)
+                    push_back(attr, *i);
+            }
+        }
+    };
+    template <typename Attribute, typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        reference_wrapper<Attribute>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , reference_wrapper<Attribute> attr)
+        {
+            if (traits::is_empty(attr))
+                attr = Attribute(first, last);
+            else {
+                for (Iterator i = first; i != last; ++i)
+                    push_back(attr, *i);
+            }
+        }
+    };
+    template <typename Attribute, typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        boost::optional<Attribute>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , boost::optional<Attribute>& attr)
+        {
+            Attribute val;
+            assign_to(first, last, val);
+            attr = val;
+        }
+    };
+    template <typename Iterator>
+    struct assign_to_attribute_from_iterators<
+        iterator_range<Iterator>, Iterator>
+    {
+        static void
+        call(Iterator const& first, Iterator const& last
+          , iterator_range<Iterator>& attr)
+        {
+            attr = iterator_range<Iterator>(first, last);
+        }
+    };
+    template <typename Iterator, typename Attribute>
+    inline void
+    assign_to(Iterator const& first, Iterator const& last, Attribute& attr)
+    {
+        assign_to_attribute_from_iterators<Attribute, Iterator>::
+            call(first, last, attr);
+    }
+    template <typename Iterator>
+    inline void
+    assign_to(Iterator const&, Iterator const&, unused_type)
+    {
+    }
+    template <typename T, typename Attribute>
+    void assign_to(T const& val, Attribute& attr);
+    template <typename Attribute, typename T, typename Enable>
+    struct assign_to_attribute_from_value
+    {
+        typedef typename traits::one_element_sequence<Attribute>::type
+            is_one_element_sequence;
+        typedef typename mpl::eval_if<
+            is_one_element_sequence
+          , fusion::result_of::at_c<Attribute, 0>
+          , mpl::identity<Attribute&>
+        >::type type;
+        template <typename T_>
+        static void
+        call(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            attr = static_cast<Attribute>(val);
+        }
+        template <typename T_>
+        static void
+        call(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            typedef typename fusion::result_of::value_at_c<Attribute, 0>::type
+                element_type;
+            fusion::at_c<0>(attr) = static_cast<element_type>(val);
+        }
+        static void
+        call(T const& val, Attribute& attr)
+        {
+            call(val, attr, is_one_element_sequence());
+        }
+    };
+    template <typename Attribute>
+    struct assign_to_attribute_from_value<Attribute, Attribute>
+    {
+        static void
+        call(Attribute const& val, Attribute& attr)
+        {
+            attr = val;
+        }
+    };
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, reference_wrapper<T>
+      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
+    {
+        static void
+        call(reference_wrapper<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, boost::optional<T>
+      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
+    {
+        static void
+        call(boost::optional<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+    namespace detail
+    {
+        template <typename A, typename B>
+        struct is_same_size_sequence
+          : mpl::bool_<fusion::result_of::size<A>::value
+                == fusion::result_of::size<B>::value>
+        {};
+    }
+    template <typename Attribute, typename T>
+    struct assign_to_attribute_from_value<Attribute, T,
+            mpl::and_<
+                fusion::traits::is_sequence<Attribute>,
+                fusion::traits::is_sequence<T>,
+                detail::is_same_size_sequence<Attribute, T>
+            >
+        >
+    {
+        static void
+        call(T const& val, Attribute& attr)
+        {
+            fusion::copy(val, attr);
+        }
+    };
+    template <typename Attribute, typename T, typename Enable>
+    struct assign_to_container_from_value
+    {
+        template <typename T_>
+        static void call(T_ const& val, Attribute& attr, mpl::false_, mpl::false_)
+        {
+            traits::push_back(attr, val);
+        }
+        template <typename T_>
+        static void
+        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            traits::push_back(attr, val);
+        }
+        template <typename T_>
+        static void
+        append_to_container_not_string(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            typedef typename traits::container_iterator<T_ const>::type
+                iterator_type;
+            iterator_type end = traits::end(val);
+            for (iterator_type i = traits::begin(val); i != end; traits::next(i))
+                traits::push_back(attr, traits::deref(i));
+        }
+        template <typename T_>
+        static void call(T_ const& val, Attribute& attr, mpl::true_, mpl::false_)
+        {
+            typedef typename container_value<Attribute>::type value_type;
+            typedef typename is_convertible<T, value_type>::type is_value_type;
+            append_to_container_not_string(val, attr, is_value_type());
+        }
+        template <typename Iterator>
+        static void append_to_string(Attribute& attr, Iterator begin, Iterator end)
+        {
+            for (Iterator i = begin; i != end; ++i)
+                traits::push_back(attr, *i);
+        }
+        template <typename T_>
+        static void append_to_container(T_ const& val, Attribute& attr, mpl::false_)
+        {
+            typedef typename char_type_of<T_>::type char_type;
+            append_to_string(attr, traits::get_begin<char_type>(val)
+              , traits::get_end<char_type>(val));
+        }
+        template <typename T_>
+        static void append_to_container(T_ const& val, Attribute& attr, mpl::true_)
+        {
+            traits::push_back(attr, val);
+        }
+        template <typename T_, typename Pred>
+        static void call(T_ const& val, Attribute& attr, Pred, mpl::true_)
+        {
+            typedef typename container_value<Attribute>::type value_type;
+            typedef typename is_convertible<T, value_type>::type is_value_type;
+            append_to_container(val, attr, is_value_type());
+        }
+        static void call(T const& val, Attribute& attr)
+        {
+            typedef typename traits::is_container<T>::type is_container;
+            typedef typename traits::is_string<T>::type is_string;
+            call(val, attr, is_container(), is_string());
+        }
+    };
+    template <typename Attribute>
+    struct assign_to_container_from_value<Attribute, Attribute>
+    {
+        static void
+        call(Attribute const& val, Attribute& attr)
+        {
+            attr = val;
+        }
+    };
+    template <typename Attribute, typename T>
+    struct assign_to_container_from_value<Attribute, boost::optional<T>
+      , typename disable_if<is_same<Attribute, boost::optional<T> > >::type>
+    {
+        static void
+        call(boost::optional<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+    template <typename Attribute, typename T>
+    struct assign_to_container_from_value<Attribute, reference_wrapper<T>
+      , typename disable_if<is_same<Attribute, reference_wrapper<T> > >::type>
+    {
+        static void
+        call(reference_wrapper<T> const& val, Attribute& attr)
+        {
+            assign_to(val.get(), attr);
+        }
+    };
+    namespace detail
+    {
+        template <typename T, typename Attribute>
+        inline void
+        assign_to(T const& val, Attribute& attr, mpl::false_)
+        {
+            assign_to_attribute_from_value<Attribute, T>::call(val, attr);
+        }
+        template <typename T, typename Attribute>
+        inline void
+        assign_to(T const& val, Attribute& attr, mpl::true_)
+        {
+            assign_to_container_from_value<Attribute, T>::call(val, attr);
+        }
+    }
+    template <typename T, typename Attribute>
+    inline void
+    assign_to(T const& val, Attribute& attr)
+    {
+        typedef typename mpl::and_<
+            traits::is_container<Attribute>
+          , traits::not_is_variant<Attribute>
+          , traits::not_is_optional<Attribute>
+        >::type is_not_wrapped_container;
+        detail::assign_to(val, attr, is_not_wrapped_container());
+    }
+    template <typename T>
+    inline void
+    assign_to(T const&, unused_type)
+    {
+    }
+}}}
+namespace boost { namespace spirit
+{
+    template <typename A0>
+    struct use_terminal<
+            qi::domain, terminal_ex<tag::attr, fusion::vector1<A0> > >
+      : mpl::true_ {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::attr, 1>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::attr;
+    using spirit::attr_type;
+    template <typename Value>
+    struct attr_parser : primitive_parser<attr_parser<Value> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute : remove_const<Value> {};
+        attr_parser(typename add_reference<Value>::type value)
+          : value_(value) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& , Iterator const&
+          , Context& , Skipper const&
+          , Attribute& attr) const
+        {
+            spirit::traits::assign_to(value_, attr);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("attr");
+        }
+        Value value_;
+    private:
+        attr_parser& operator= (attr_parser const&);
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::attr, fusion::vector1<A0> >
+      , Modifiers>
+    {
+        typedef typename add_const<A0>::type const_value;
+        typedef attr_parser<const_value> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::attr_parser<T>, Attr, Context, Iterator>
+      : traits::is_container<Attr> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Expr>
+    typename enable_if<proto::is_expr<Expr>
+      , stateful_tag_type<Expr, tag::attr_cast> >::type
+    attr_cast(Expr const& expr)
+    {
+        return stateful_tag_type<Expr, tag::attr_cast>(expr);
+    }
+    template <typename Exposed, typename Expr>
+    typename enable_if<proto::is_expr<Expr>
+      , stateful_tag_type<Expr, tag::attr_cast, Exposed> >::type
+    attr_cast(Expr const& expr)
+    {
+        return stateful_tag_type<Expr, tag::attr_cast, Exposed>(expr);
+    }
+    template <typename Exposed, typename Transformed, typename Expr>
+    typename enable_if<proto::is_expr<Expr>
+      , stateful_tag_type<Expr, tag::attr_cast, Exposed, Transformed> >::type
+    attr_cast(Expr const& expr)
+    {
+        return stateful_tag_type<Expr, tag::attr_cast, Exposed, Transformed>(expr);
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <typename Expr, typename Exposed, typename Transformed>
+    struct use_terminal<qi::domain
+          , tag::stateful_tag<Expr, tag::attr_cast, Exposed, Transformed> >
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::attr_cast;
+    template <typename Exposed, typename Transformed, typename Subject>
+    struct attr_cast_parser
+      : unary_parser<attr_cast_parser<Exposed, Transformed, Subject> >
+    {
+        typedef typename result_of::compile<qi::domain, Subject>::type
+            subject_type;
+        typedef typename mpl::eval_if<
+            traits::not_is_unused<Transformed>
+          , mpl::identity<Transformed>
+          , traits::attribute_of<subject_type> >::type
+        transformed_attribute_type;
+        attr_cast_parser(Subject const& subject)
+          : subject(subject)
+        {
+            struct error_invalid_expression; typedef struct error_invalid_expression62 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Subject) { return 0; } } mpl_assert_arg62; enum { mpl_assertion_in_line_62 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Subject>::value ))>( mpl_assert_arg62::assert_arg() ) ) };
+        }
+        template <typename Context, typename Iterator>
+        struct attribute
+          : mpl::if_<traits::not_is_unused<Exposed>, Exposed
+              , transformed_attribute_type>
+        {};
+        template <typename Iterator, typename Context, typename Skipper
+          , typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef typename mpl::if_<
+                traits::not_is_unused<Exposed>, Exposed, Attribute>::type
+            exposed_attribute_type;
+            typedef traits::transform_attribute<
+                exposed_attribute_type, transformed_attribute_type, domain>
+            transform;
+            typename transform::type attr_ = transform::pre(attr);
+            if (!compile<qi::domain>(subject).
+                    parse(first, last, context, skipper, attr_))
+            {
+                transform::fail(attr);
+                return false;
+            }
+            traits::post_transform(attr, attr_);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("attr_cast"
+              , compile<qi::domain>(subject).what(context));
+        }
+        Subject subject;
+    private:
+        attr_cast_parser& operator= (attr_cast_parser const&);
+    };
+    template <typename Expr, typename Exposed, typename Transformed
+      , typename Modifiers>
+    struct make_primitive<
+        tag::stateful_tag<Expr, tag::attr_cast, Exposed, Transformed>, Modifiers>
+    {
+        typedef attr_cast_parser<Exposed, Transformed, Expr> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            typedef tag::stateful_tag<
+                Expr, tag::attr_cast, Exposed, Transformed> tag_type;
+            using spirit::detail::get_stateful_data;
+            return result_type(get_stateful_data<tag_type>::call(term));
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::complement>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace traits
+{
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_char_parser_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::char_parser_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename T>
+    struct is_char_parser : detail::has_char_parser_id<T> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Derived, typename Char, typename Attr = Char>
+    struct char_parser : primitive_parser<Derived>
+    {
+        typedef Char char_type;
+        struct char_parser_id;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef Attr type;
+        };
+        template <typename Iterator, typename Context, typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            if (first != last && this->derived().test(*first, context))
+            {
+                spirit::traits::assign_to(*first, attr);
+                ++first;
+                return true;
+            }
+            return false;
+        }
+    };
+    template <typename Positive>
+    struct negated_char_parser :
+        char_parser<negated_char_parser<Positive>, typename Positive::char_type>
+    {
+        negated_char_parser(Positive const& positive)
+          : positive(positive) {}
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch, Context& context) const
+        {
+            return !positive.test(ch, context);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("not", positive.what(context));
+        }
+        Positive positive;
+    };
+    namespace detail
+    {
+        template <typename Positive>
+        struct make_negated_char_parser
+        {
+            typedef negated_char_parser<Positive> result_type;
+            result_type operator()(Positive const& positive) const
+            {
+                return result_type(positive);
+            }
+        };
+        template <typename Positive>
+        struct make_negated_char_parser<negated_char_parser<Positive> >
+        {
+            typedef Positive result_type;
+            result_type operator()(negated_char_parser<Positive> const& ncp) const
+            {
+                return ncp.positive;
+            }
+        };
+    }
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::complement, Elements, Modifiers>
+    {
+        typedef typename
+            fusion::result_of::value_at_c<Elements, 0>::type
+        subject;
+        struct subject_is_not_negatable; typedef struct
+ subject_is_not_negatable143
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (subject_is_not_negatable::************ assert_arg()) (subject) { return 0; } }
+ mpl_assert_arg143
+        ; enum { mpl_assertion_in_line_143 = sizeof( boost::mpl::assertion_failed<(( traits::is_char_parser<subject>::value ))>( mpl_assert_arg143::assert_arg() ) ) }
+                                               ;
+        typedef typename
+            detail::make_negated_char_parser<subject>::result_type
+        result_type;
+        result_type operator()(Elements const& elements, unused_type) const
+        {
+            return detail::make_negated_char_parser<subject>()(
+                fusion::at_c<0>(elements));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Modifiers, typename Encoding>
+    struct get_implicit_encoding
+    {
+        typedef typename
+            mpl::find_if<
+                char_encodings,
+                has_modifier<Modifiers, tag::char_encoding_base<mpl::_1> >
+            >::type
+        iter;
+        typedef typename
+            mpl::eval_if<
+                is_same<iter, typename mpl::end<char_encodings>::type>,
+                mpl::identity<Encoding>,
+                mpl::deref<iter>
+            >::type
+        type;
+    };
+    template <typename Modifiers, typename Encoding>
+    struct get_encoding
+    {
+        typedef typename
+            mpl::find_if<
+                char_encodings,
+                has_modifier<Modifiers, tag::char_code<tag::encoding, mpl::_1> >
+            >::type
+        iter;
+        typedef typename
+            mpl::eval_if<
+                is_same<iter, typename mpl::end<char_encodings>::type>,
+                get_implicit_encoding<Modifiers, Encoding>,
+                mpl::deref<iter>
+            >::type
+        type;
+    };
+    template <typename Modifiers, typename Encoding, bool case_modifier = false>
+    struct get_encoding_with_case : mpl::identity<Encoding> {};
+    template <typename Modifiers, typename Encoding>
+    struct get_encoding_with_case<Modifiers, Encoding, true>
+        : get_encoding<Modifiers, Encoding> {};
+}}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<size_t _Nw>
+    struct _Base_bitset
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w[_Nw];
+      _Base_bitset()
+      : _M_w() { }
+      _Base_bitset(unsigned long __val)
+      : _M_w()
+      { _M_w[0] = __val; }
+      static size_t
+      _S_whichword(size_t __pos )
+      { return __pos / (8 * 8); }
+      static size_t
+      _S_whichbyte(size_t __pos )
+      { return (__pos % (8 * 8)) / 8; }
+      static size_t
+      _S_whichbit(size_t __pos )
+      { return __pos % (8 * 8); }
+      static _WordT
+      _S_maskbit(size_t __pos )
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+      _WordT&
+      _M_getword(size_t __pos)
+      { return _M_w[_S_whichword(__pos)]; }
+      _WordT
+      _M_getword(size_t __pos) const
+      { return _M_w[_S_whichword(__pos)]; }
+      _WordT&
+      _M_hiword()
+      { return _M_w[_Nw - 1]; }
+      _WordT
+      _M_hiword() const
+      { return _M_w[_Nw - 1]; }
+      void
+      _M_do_and(const _Base_bitset<_Nw>& __x)
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] &= __x._M_w[__i];
+      }
+      void
+      _M_do_or(const _Base_bitset<_Nw>& __x)
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] |= __x._M_w[__i];
+      }
+      void
+      _M_do_xor(const _Base_bitset<_Nw>& __x)
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] ^= __x._M_w[__i];
+      }
+      void
+      _M_do_left_shift(size_t __shift);
+      void
+      _M_do_right_shift(size_t __shift);
+      void
+      _M_do_flip()
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~_M_w[__i];
+      }
+      void
+      _M_do_set()
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~static_cast<_WordT>(0);
+      }
+      void
+      _M_do_reset()
+      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+      bool
+      _M_is_equal(const _Base_bitset<_Nw>& __x) const
+      {
+ for (size_t __i = 0; __i < _Nw; ++__i)
+   if (_M_w[__i] != __x._M_w[__i])
+     return false;
+ return true;
+      }
+      size_t
+      _M_are_all_aux() const
+      {
+ for (size_t __i = 0; __i < _Nw - 1; __i++)
+   if (_M_w[__i] != ~static_cast<_WordT>(0))
+     return 0;
+ return ((_Nw - 1) * (8 * 8)
+  + __builtin_popcountl(_M_hiword()));
+      }
+      bool
+      _M_is_any() const
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   if (_M_w[__i] != static_cast<_WordT>(0))
+     return true;
+ return false;
+      }
+      size_t
+      _M_do_count() const
+      {
+ size_t __result = 0;
+ for (size_t __i = 0; __i < _Nw; __i++)
+   __result += __builtin_popcountl(_M_w[__i]);
+ return __result;
+      }
+      unsigned long
+      _M_do_to_ulong() const;
+      size_t
+      _M_do_find_first(size_t __not_found) const;
+      size_t
+      _M_do_find_next(size_t __prev, size_t __not_found) const;
+    };
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+   if (__offset == 0)
+     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+       _M_w[__n] = _M_w[__n - __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
+        | (_M_w[__n - __wshift - 1] >> __sub_offset));
+       _M_w[__wshift] = _M_w[0] << __offset;
+     }
+   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
+ }
+    }
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+   const size_t __limit = _Nw - __wshift - 1;
+   if (__offset == 0)
+     for (size_t __n = 0; __n <= __limit; ++__n)
+       _M_w[__n] = _M_w[__n + __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = 0; __n < __limit; ++__n)
+  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
+        | (_M_w[__n + __wshift + 1] << __sub_offset));
+       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+     }
+   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
+ }
+    }
+  template<size_t _Nw>
+    unsigned long
+    _Base_bitset<_Nw>::_M_do_to_ulong() const
+    {
+      for (size_t __i = 1; __i < _Nw; ++__i)
+ if (_M_w[__i])
+   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
+      return _M_w[0];
+    }
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const
+    {
+      for (size_t __i = 0; __i < _Nw; __i++)
+ {
+   _WordT __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+      return __not_found;
+    }
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const
+    {
+      ++__prev;
+      if (__prev >= _Nw * (8 * 8))
+ return __not_found;
+      size_t __i = _S_whichword(__prev);
+      _WordT __thisword = _M_w[__i];
+      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+      if (__thisword != static_cast<_WordT>(0))
+ return (__i * (8 * 8)
+  + __builtin_ctzl(__thisword));
+      __i++;
+      for (; __i < _Nw; __i++)
+ {
+   __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+      return __not_found;
+    }
+  template<>
+    struct _Base_bitset<1>
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w;
+      _Base_bitset()
+      : _M_w(0)
+      { }
+      _Base_bitset(unsigned long __val)
+      : _M_w(__val)
+      { }
+      static size_t
+      _S_whichword(size_t __pos )
+      { return __pos / (8 * 8); }
+      static size_t
+      _S_whichbyte(size_t __pos )
+      { return (__pos % (8 * 8)) / 8; }
+      static size_t
+      _S_whichbit(size_t __pos )
+      { return __pos % (8 * 8); }
+      static _WordT
+      _S_maskbit(size_t __pos )
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+      _WordT&
+      _M_getword(size_t)
+      { return _M_w; }
+      _WordT
+      _M_getword(size_t) const
+      { return _M_w; }
+      _WordT&
+      _M_hiword()
+      { return _M_w; }
+      _WordT
+      _M_hiword() const
+      { return _M_w; }
+      void
+      _M_do_and(const _Base_bitset<1>& __x)
+      { _M_w &= __x._M_w; }
+      void
+      _M_do_or(const _Base_bitset<1>& __x)
+      { _M_w |= __x._M_w; }
+      void
+      _M_do_xor(const _Base_bitset<1>& __x)
+      { _M_w ^= __x._M_w; }
+      void
+      _M_do_left_shift(size_t __shift)
+      { _M_w <<= __shift; }
+      void
+      _M_do_right_shift(size_t __shift)
+      { _M_w >>= __shift; }
+      void
+      _M_do_flip()
+      { _M_w = ~_M_w; }
+      void
+      _M_do_set()
+      { _M_w = ~static_cast<_WordT>(0); }
+      void
+      _M_do_reset()
+      { _M_w = 0; }
+      bool
+      _M_is_equal(const _Base_bitset<1>& __x) const
+      { return _M_w == __x._M_w; }
+      size_t
+      _M_are_all_aux() const
+      { return __builtin_popcountl(_M_w); }
+      bool
+      _M_is_any() const
+      { return _M_w != 0; }
+      size_t
+      _M_do_count() const
+      { return __builtin_popcountl(_M_w); }
+      unsigned long
+      _M_do_to_ulong() const
+      { return _M_w; }
+      size_t
+      _M_do_find_first(size_t __not_found) const
+      {
+        if (_M_w != 0)
+          return __builtin_ctzl(_M_w);
+        else
+          return __not_found;
+      }
+      size_t
+      _M_do_find_next(size_t __prev, size_t __not_found) const
+      {
+ ++__prev;
+ if (__prev >= ((size_t) (8 * 8)))
+   return __not_found;
+ _WordT __x = _M_w >> __prev;
+ if (__x != 0)
+   return __builtin_ctzl(__x) + __prev;
+ else
+   return __not_found;
+      }
+    };
+  template<>
+    struct _Base_bitset<0>
+    {
+      typedef unsigned long _WordT;
+      _Base_bitset()
+      { }
+      _Base_bitset(unsigned long)
+      { }
+      static size_t
+      _S_whichword(size_t __pos )
+      { return __pos / (8 * 8); }
+      static size_t
+      _S_whichbyte(size_t __pos )
+      { return (__pos % (8 * 8)) / 8; }
+      static size_t
+      _S_whichbit(size_t __pos )
+      { return __pos % (8 * 8); }
+      static _WordT
+      _S_maskbit(size_t __pos )
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+      _WordT&
+      _M_getword(size_t)
+      {
+ __throw_out_of_range(("_Base_bitset::_M_getword"));
+ return *new _WordT;
+      }
+      _WordT
+      _M_getword(size_t __pos) const
+      { return 0; }
+      _WordT
+      _M_hiword() const
+      { return 0; }
+      void
+      _M_do_and(const _Base_bitset<0>&)
+      { }
+      void
+      _M_do_or(const _Base_bitset<0>&)
+      { }
+      void
+      _M_do_xor(const _Base_bitset<0>&)
+      { }
+      void
+      _M_do_left_shift(size_t)
+      { }
+      void
+      _M_do_right_shift(size_t)
+      { }
+      void
+      _M_do_flip()
+      { }
+      void
+      _M_do_set()
+      { }
+      void
+      _M_do_reset()
+      { }
+      bool
+      _M_is_equal(const _Base_bitset<0>&) const
+      { return true; }
+      size_t
+      _M_are_all_aux() const
+      { return 0; }
+      bool
+      _M_is_any() const
+      { return false; }
+      size_t
+      _M_do_count() const
+      { return 0; }
+      unsigned long
+      _M_do_to_ulong() const
+      { return 0; }
+      size_t
+      _M_do_find_first(size_t) const
+      { return 0; }
+      size_t
+      _M_do_find_next(size_t, size_t) const
+      { return 0; }
+    };
+  template<size_t _Extrabits>
+    struct _Sanitize
+    {
+      typedef unsigned long _WordT;
+      static void
+      _S_do_sanitize(_WordT& __val)
+      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
+    };
+  template<>
+    struct _Sanitize<0>
+    {
+      typedef unsigned long _WordT;
+      static void
+      _S_do_sanitize(_WordT) { }
+    };
+  template<size_t _Nb>
+    class bitset
+    : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
+    {
+    private:
+      typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
+      typedef unsigned long _WordT;
+      void
+      _M_do_sanitize()
+      {
+ typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
+ __sanitize_type::_S_do_sanitize(this->_M_hiword());
+      }
+    public:
+      class reference
+      {
+ friend class bitset;
+ _WordT* _M_wp;
+ size_t _M_bpos;
+ reference();
+      public:
+ reference(bitset& __b, size_t __pos)
+ {
+   _M_wp = &__b._M_getword(__pos);
+   _M_bpos = _Base::_S_whichbit(__pos);
+ }
+ ~reference()
+ { }
+ reference&
+ operator=(bool __x)
+ {
+   if (__x)
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+ reference&
+ operator=(const reference& __j)
+ {
+   if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+ bool
+ operator~() const
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
+ operator bool() const
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
+ reference&
+ flip()
+ {
+   *_M_wp ^= _Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+      };
+      friend class reference;
+      bitset()
+      { }
+      bitset(unsigned long __val)
+      : _Base(__val)
+      { _M_do_sanitize(); }
+      template<class _CharT, class _Traits, class _Alloc>
+ explicit
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position = 0)
+ : _Base()
+ {
+   if (__position > __s.size())
+     __throw_out_of_range(("bitset::bitset initial position " "not valid")
+                     );
+   _M_copy_from_string(__s, __position,
+         std::basic_string<_CharT, _Traits, _Alloc>::npos,
+         _CharT('0'), _CharT('1'));
+ }
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n)
+ : _Base()
+ {
+   if (__position > __s.size())
+     __throw_out_of_range(("bitset::bitset initial position " "not valid")
+                     );
+   _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
+ }
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n,
+        _CharT __zero, _CharT __one = _CharT('1'))
+ : _Base()
+ {
+   if (__position > __s.size())
+     __throw_out_of_range(("bitset::bitset initial position " "not valid")
+                     );
+   _M_copy_from_string(__s, __position, __n, __zero, __one);
+ }
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs)
+      {
+ this->_M_do_and(__rhs);
+ return *this;
+      }
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs)
+      {
+ this->_M_do_or(__rhs);
+ return *this;
+      }
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs)
+      {
+ this->_M_do_xor(__rhs);
+ return *this;
+      }
+      bitset<_Nb>&
+      operator<<=(size_t __position)
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_left_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+      bitset<_Nb>&
+      operator>>=(size_t __position)
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_right_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos)
+      {
+ this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos, int __val)
+      {
+ if (__val)
+   this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ else
+   this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+      bitset<_Nb>&
+      _Unchecked_reset(size_t __pos)
+      {
+ this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+      bitset<_Nb>&
+      _Unchecked_flip(size_t __pos)
+      {
+ this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+      bool
+      _Unchecked_test(size_t __pos) const
+      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
+  != static_cast<_WordT>(0)); }
+      bitset<_Nb>&
+      set()
+      {
+ this->_M_do_set();
+ this->_M_do_sanitize();
+ return *this;
+      }
+      bitset<_Nb>&
+      set(size_t __position, bool __val = true)
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range(("bitset::set"));
+ return _Unchecked_set(__position, __val);
+      }
+      bitset<_Nb>&
+      reset()
+      {
+ this->_M_do_reset();
+ return *this;
+      }
+      bitset<_Nb>&
+      reset(size_t __position)
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range(("bitset::reset"));
+ return _Unchecked_reset(__position);
+      }
+      bitset<_Nb>&
+      flip()
+      {
+ this->_M_do_flip();
+ this->_M_do_sanitize();
+ return *this;
+      }
+      bitset<_Nb>&
+      flip(size_t __position)
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range(("bitset::flip"));
+ return _Unchecked_flip(__position);
+      }
+      bitset<_Nb>
+      operator~() const
+      { return bitset<_Nb>(*this).flip(); }
+      reference
+      operator[](size_t __position)
+      { return reference(*this, __position); }
+      bool
+      operator[](size_t __position) const
+      { return _Unchecked_test(__position); }
+      unsigned long
+      to_ulong() const
+      { return this->_M_do_to_ulong(); }
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string() const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
+   return __result;
+ }
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, __zero, __one);
+   return __result;
+ }
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string() const
+ { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ { return to_string<_CharT, _Traits,
+                    std::allocator<_CharT> >(__zero, __one); }
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string() const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >();
+ }
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >(__zero, __one);
+ }
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >();
+      }
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >(__zero, __one);
+      }
+      template<class _CharT, class _Traits>
+        void
+        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
+    _CharT, _CharT);
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n,
+       _CharT __zero, _CharT __one)
+ { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
+         __zero, __one); }
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
+     _CharT, _CharT) const;
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n)
+ { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
+ { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
+      size_t
+      count() const
+      { return this->_M_do_count(); }
+      size_t
+      size() const
+      { return _Nb; }
+      bool
+      operator==(const bitset<_Nb>& __rhs) const
+      { return this->_M_is_equal(__rhs); }
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const
+      { return !this->_M_is_equal(__rhs); }
+      bool
+      test(size_t __position) const
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range(("bitset::test"));
+ return _Unchecked_test(__position);
+      }
+      bool
+      all() const
+      { return this->_M_are_all_aux() == _Nb; }
+      bool
+      any() const
+      { return this->_M_is_any(); }
+      bool
+      none() const
+      { return !this->_M_is_any(); }
+      bitset<_Nb>
+      operator<<(size_t __position) const
+      { return bitset<_Nb>(*this) <<= __position; }
+      bitset<_Nb>
+      operator>>(size_t __position) const
+      { return bitset<_Nb>(*this) >>= __position; }
+      size_t
+      _Find_first() const
+      { return this->_M_do_find_first(_Nb); }
+      size_t
+      _Find_next(size_t __prev ) const
+      { return this->_M_do_find_next(__prev, _Nb); }
+    };
+  template<size_t _Nb>
+    template<class _CharT, class _Traits>
+      void
+      bitset<_Nb>::
+      _M_copy_from_ptr(const _CharT* __s, size_t __len,
+         size_t __pos, size_t __n, _CharT __zero, _CharT __one)
+      {
+ reset();
+ const size_t __nbits = std::min(_Nb, std::min(__n, __len - __pos));
+ for (size_t __i = __nbits; __i > 0; --__i)
+   {
+     const _CharT __c = __s[__pos + __nbits - __i];
+     if (_Traits::eq(__c, __zero))
+       ;
+     else if (_Traits::eq(__c, __one))
+       _Unchecked_set(__i - 1);
+     else
+       __throw_invalid_argument(("bitset::_M_copy_from_ptr"));
+   }
+      }
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+      void
+      bitset<_Nb>::
+      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
+   _CharT __zero, _CharT __one) const
+      {
+ __s.assign(_Nb, __zero);
+ for (size_t __i = _Nb; __i > 0; --__i)
+   if (_Unchecked_test(__i - 1))
+     _Traits::assign(__s[_Nb - __i], __one);
+      }
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
+    {
+      bitset<_Nb> __result(__x);
+      __result &= __y;
+      return __result;
+    }
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
+    {
+      bitset<_Nb> __result(__x);
+      __result |= __y;
+      return __result;
+    }
+  template <size_t _Nb>
+    inline bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
+    {
+      bitset<_Nb> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
+  template<class _CharT, class _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    {
+      typedef typename _Traits::char_type char_type;
+      typedef std::basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      std::basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(_Nb);
+      const char_type __zero = __is.widen('0');
+      const char_type __one = __is.widen('1');
+      typename __ios_base::iostate __state = __ios_base::goodbit;
+      typename __istream_type::sentry __sentry(__is);
+      if (__sentry)
+ {
+   try
+     {
+       for (size_t __i = _Nb; __i > 0; --__i)
+  {
+    static typename _Traits::int_type __eof = _Traits::eof();
+    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
+    if (_Traits::eq_int_type(__c1, __eof))
+      {
+        __state |= __ios_base::eofbit;
+        break;
+      }
+    else
+      {
+        const char_type __c2 = _Traits::to_char_type(__c1);
+        if (_Traits::eq(__c2, __zero))
+   __tmp.push_back(__zero);
+        else if (_Traits::eq(__c2, __one))
+   __tmp.push_back(__one);
+        else if (_Traits::
+          eq_int_type(__is.rdbuf()->sputbackc(__c2),
+        __eof))
+   {
+     __state |= __ios_base::failbit;
+     break;
+   }
+      }
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __is._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __is._M_setstate(__ios_base::badbit); }
+ }
+      if (__tmp.empty() && _Nb)
+ __state |= __ios_base::failbit;
+      else
+ __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
+    __zero, __one);
+      if (__state)
+ __is.setstate(__state);
+      return __is;
+    }
+  template <class _CharT, class _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const bitset<_Nb>& __x)
+    {
+      std::basic_string<_CharT, _Traits> __tmp;
+      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
+      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
+      return __os << __tmp;
+    }
+}
+namespace boost { namespace spirit { namespace support { namespace detail
+{
+    template <typename T>
+    struct range
+    {
+        typedef T value_type;
+        range() : first(), last() {}
+        range(T first, T last) : first(first), last(last) {}
+        T first;
+        T last;
+    };
+}}}}
+namespace boost { namespace spirit { namespace support { namespace detail
+{
+    template <typename Char>
+    class range_run
+    {
+    public:
+        typedef range<Char> range_type;
+        typedef std::vector<range_type> storage_type;
+        void swap(range_run& other);
+        bool test(Char v) const;
+        void set(range_type const& range);
+        void clear(range_type const& range);
+        void clear();
+    private:
+        storage_type run;
+    };
+}}}}
+namespace boost {
+template<class T>
+class integer_traits : public std::numeric_limits<T>
+{
+public:
+  static const bool is_integral = false;
+};
+namespace detail {
+template<class T, T min_val, T max_val>
+class integer_traits_base
+{
+public:
+  static const bool is_integral = true;
+  static const T const_min = min_val;
+  static const T const_max = max_val;
+};
+template<class T, T min_val, T max_val>
+const bool integer_traits_base<T, min_val, max_val>::is_integral;
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_min;
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_max;
+}
+template<>
+class integer_traits<bool>
+  : public std::numeric_limits<bool>,
+    public detail::integer_traits_base<bool, false, true>
+{ };
+template<>
+class integer_traits<char>
+  : public std::numeric_limits<char>,
+    public detail::integer_traits_base<char, 0, (127 * 2 + 1)>
+{ };
+template<>
+class integer_traits<signed char>
+  : public std::numeric_limits<signed char>,
+    public detail::integer_traits_base<signed char, (-127 - 1), 127>
+{ };
+template<>
+class integer_traits<unsigned char>
+  : public std::numeric_limits<unsigned char>,
+    public detail::integer_traits_base<unsigned char, 0, (127 * 2 + 1)>
+{ };
+template<>
+class integer_traits<wchar_t>
+  : public std::numeric_limits<wchar_t>,
+    public detail::integer_traits_base<wchar_t, (-2147483647 - 1), (2147483647)>
+{ };
+template<>
+class integer_traits<short>
+  : public std::numeric_limits<short>,
+    public detail::integer_traits_base<short, (-32767 - 1), 32767>
+{ };
+template<>
+class integer_traits<unsigned short>
+  : public std::numeric_limits<unsigned short>,
+    public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
+{ };
+template<>
+class integer_traits<int>
+  : public std::numeric_limits<int>,
+    public detail::integer_traits_base<int, (-2147483647 - 1), 2147483647>
+{ };
+template<>
+class integer_traits<unsigned int>
+  : public std::numeric_limits<unsigned int>,
+    public detail::integer_traits_base<unsigned int, 0, (2147483647 * 2U + 1U)>
+{ };
+template<>
+class integer_traits<long>
+  : public std::numeric_limits<long>,
+    public detail::integer_traits_base<long, (-9223372036854775807L - 1L), 9223372036854775807L>
+{ };
+template<>
+class integer_traits<unsigned long>
+  : public std::numeric_limits<unsigned long>,
+    public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L * 2UL + 1UL)>
+{ };
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1), 9223372036854775807LL>
+{ };
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL * 2ULL + 1)>
+{ };
+}
+namespace boost { namespace spirit { namespace support { namespace detail
+{
+    template <typename Range>
+    inline bool
+    is_valid(Range const& range)
+    {
+        return range.first <= range.last;
+    }
+    template <typename Range>
+    inline bool
+    includes(Range const& range, Range const& other)
+    {
+        return (range.first <= other.first) && (range.last >= other.last);
+    }
+    template <typename Range>
+    inline bool
+    includes(Range const& range, typename Range::value_type val)
+    {
+        return (range.first <= val) && (range.last >= val);
+    }
+    template <typename Range>
+    inline bool
+    can_merge(Range const& range, Range const& other)
+    {
+        typedef typename Range::value_type value_type;
+        typedef integer_traits<value_type> integer_traits;
+        value_type decr_first =
+            range.first == integer_traits::const_min
+            ? range.first : range.first-1;
+        value_type incr_last =
+            range.last == integer_traits::const_max
+            ? range.last : range.last+1;
+        return (decr_first <= other.last) && (incr_last >= other.first);
+    }
+    template <typename Range>
+    inline void
+    merge(Range& result, Range const& other)
+    {
+        if (result.first > other.first)
+            result.first = other.first;
+        if (result.last < other.last)
+            result.last = other.last;
+    }
+    template <typename Range>
+    struct range_compare
+    {
+        typedef typename Range::value_type value_type;
+        bool operator()(Range const& x, const value_type y) const
+        {
+            return x.first < y;
+        }
+        bool operator()(value_type const x, Range const& y) const
+        {
+            return x < y.first;
+        }
+        bool operator()(Range const& x, Range const& y) const
+        {
+            return x.first < y.first;
+        }
+    };
+}}}}
+namespace boost { namespace spirit { namespace support { namespace detail
+{
+    template <typename Run, typename Iterator, typename Range>
+    inline bool
+    try_merge(Run& run, Iterator iter, Range const& range)
+    {
+        if (can_merge(*iter, range))
+        {
+            typedef typename Range::value_type value_type;
+            typedef integer_traits<value_type> integer_traits;
+            merge(*iter, range);
+            Iterator i = iter+1;
+            while (i != run.end() && i->last <= iter->last)
+                ++i;
+            if (i != run.end() && i->first-1 <= iter->last)
+            {
+                iter->last = i->last;
+                ++i;
+            }
+            run.erase(iter+1, i);
+            return true;
+        }
+        return false;
+    }
+    template <typename Char>
+    inline bool
+    range_run<Char>::test(Char val) const
+    {
+        if (run.empty())
+            return false;
+        typename storage_type::const_iterator iter =
+            std::upper_bound(
+                run.begin(), run.end(), val,
+                range_compare<range_type>()
+            );
+        return iter != run.begin() && includes(*(--iter), val);
+    }
+    template <typename Char>
+    inline void
+    range_run<Char>::swap(range_run& other)
+    {
+        run.swap(other.run);
+    }
+    template <typename Char>
+    void
+    range_run<Char>::set(range_type const& range)
+    {
+        (static_cast<void> (0));
+        if (run.empty())
+        {
+            run.push_back(range);
+            return;
+        }
+        typename storage_type::iterator iter =
+            std::upper_bound(
+                run.begin(), run.end(), range,
+                range_compare<range_type>()
+            );
+        if (iter != run.begin())
+        {
+            if (includes(*(iter-1), range))
+            {
+                return;
+            }
+            if (try_merge(run, iter-1, range))
+            {
+                return;
+            }
+        }
+        if (iter == run.end() || !try_merge(run, iter, range))
+        {
+            run.insert(iter, range);
+        }
+    }
+    template <typename Char>
+    void
+    range_run<Char>::clear(range_type const& range)
+    {
+        (static_cast<void> (0));
+        if (!run.empty())
+        {
+            typename storage_type::iterator iter =
+                std::upper_bound(
+                    run.begin(), run.end(), range,
+                    range_compare<range_type>()
+                );
+            if (iter != run.begin())
+            {
+                typename storage_type::iterator const left_iter = iter-1;
+                if (left_iter->first < range.first)
+                {
+                    if (left_iter->last > range.last)
+                    {
+                        Char save_last = left_iter->last;
+                        left_iter->last = range.first-1;
+                        run.insert(iter, range_type(range.last+1, save_last));
+                        return;
+                    }
+                    else if (left_iter->last >= range.first)
+                    {
+                        left_iter->last = range.first-1;
+                    }
+                }
+                else
+                {
+                    iter = left_iter;
+                }
+            }
+            typename storage_type::iterator i = iter;
+            while (i != run.end() && i->last <= range.last)
+                ++i;
+            if (i != run.end() && i->first <= range.last)
+                i->first = range.last+1;
+            run.erase(iter, i);
+        }
+    }
+    template <typename Char>
+    inline void
+    range_run<Char>::clear()
+    {
+        run.clear();
+    }
+}}}}
+namespace boost { namespace spirit { namespace support { namespace detail
+{
+    template <typename Char>
+    struct basic_chset
+    {
+        basic_chset() {}
+        basic_chset(basic_chset const& arg_)
+          : rr(arg_.rr) {}
+        bool
+        test(Char v) const
+        {
+            return rr.test(v);
+        }
+        void
+        set(Char from, Char to)
+        {
+            rr.set(range<Char>(from, to));
+        }
+        void
+        set(Char c)
+        {
+            rr.set(range<Char>(c, c));
+        }
+        void
+        clear(Char from, Char to)
+        {
+            rr.clear(range<Char>(from, to));
+        }
+        void
+        clear(Char c)
+        {
+            rr.clear(range<Char>(c, c));
+        }
+        void
+        clear()
+        {
+            rr.clear();
+        }
+        void
+        inverse()
+        {
+            basic_chset inv;
+            inv.set(
+                (std::numeric_limits<Char>::min)(),
+                (std::numeric_limits<Char>::max)()
+            );
+            inv -= *this;
+            swap(inv);
+        }
+        void
+        swap(basic_chset& x)
+        {
+            rr.swap(x.rr);
+        }
+        basic_chset&
+        operator|=(basic_chset const& x)
+        {
+            typedef typename range_run<Char>::const_iterator const_iterator;
+            for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
+                rr.set(*iter);
+            return *this;
+        }
+        basic_chset&
+        operator&=(basic_chset const& x)
+        {
+            basic_chset inv;
+            inv.set(
+                (std::numeric_limits<Char>::min)(),
+                (std::numeric_limits<Char>::max)()
+            );
+            inv -= x;
+            *this -= inv;
+            return *this;
+        }
+        basic_chset&
+        operator-=(basic_chset const& x)
+        {
+            typedef typename range_run<Char>::const_iterator const_iterator;
+            for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
+                rr.clear(*iter);
+            return *this;
+        }
+        basic_chset&
+        operator^=(basic_chset const& x)
+        {
+            basic_chset bma = x;
+            bma -= *this;
+            *this -= x;
+            *this |= bma;
+            return *this;
+        }
+        private: range_run<Char> rr;
+    };
+    template <typename Char>
+    struct basic_chset_8bit
+    {
+        basic_chset_8bit() {}
+        basic_chset_8bit(basic_chset_8bit const& arg_)
+          : bset(arg_.bset) {}
+        bool
+        test(Char v) const
+        {
+            return bset.test((unsigned char)v);
+        }
+        void
+        set(Char from, Char to)
+        {
+            for (int i = from; i <= to; ++i)
+                bset.set((unsigned char)i);
+        }
+        void
+        set(Char c)
+        {
+            bset.set((unsigned char)c);
+        }
+        void
+        clear(Char from, Char to)
+        {
+            for (int i = from; i <= to; ++i)
+                bset.reset((unsigned char)i);
+        }
+        void
+        clear(Char c)
+        {
+            bset.reset((unsigned char)c);
+        }
+        void
+        clear()
+        {
+            bset.reset();
+        }
+        void
+        inverse()
+        {
+            bset.flip();
+        }
+        void
+        swap(basic_chset_8bit& x)
+        {
+            std::swap(bset, x.bset);
+        }
+        basic_chset_8bit&
+        operator|=(basic_chset_8bit const& x)
+        {
+            bset |= x.bset;
+            return *this;
+        }
+        basic_chset_8bit&
+        operator&=(basic_chset_8bit const& x)
+        {
+            bset &= x.bset;
+            return *this;
+        }
+        basic_chset_8bit&
+        operator-=(basic_chset_8bit const& x)
+        {
+            bset &= ~x.bset;
+            return *this;
+        }
+        basic_chset_8bit&
+        operator^=(basic_chset_8bit const& x)
+        {
+            bset ^= x.bset;
+            return *this;
+        }
+        private: std::bitset<256> bset;
+    };
+    template <>
+    struct basic_chset<char>
+      : basic_chset_8bit<char> {};
+    template <>
+    struct basic_chset<signed char>
+      : basic_chset_8bit<signed char> {};
+    template <>
+    struct basic_chset<unsigned char>
+      : basic_chset_8bit<unsigned char> {};
+}}}}
+namespace boost { namespace spirit
+{
+    template <typename CharClass, typename CharEncoding>
+    struct use_terminal<qi::domain, tag::char_code<CharClass, CharEncoding> >
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    namespace ascii { using namespace boost::spirit::ascii; }
+    namespace iso8859_1 { using namespace boost::spirit::iso8859_1; }
+    namespace standard { using namespace boost::spirit::standard; }
+    namespace standard_wide { using namespace boost::spirit::standard_wide; }
+    using namespace boost::spirit::standard;
+    using spirit::encoding;
+    template <typename Tag>
+    struct char_class
+      : char_parser<char_class<Tag>, typename Tag::char_encoding::char_type>
+    {
+        typedef typename Tag::char_encoding char_encoding;
+        typedef typename Tag::char_class classification;
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch, Context&) const
+        {
+            using spirit::char_class::classify;
+            return traits::ischar<CharParam, char_encoding>::call(ch) &&
+                   classify<char_encoding>::is(classification(), ch);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            typedef spirit::char_class::what<char_encoding> what_;
+            return info(what_::is(classification()));
+        }
+    };
+    namespace detail
+    {
+        template <typename Tag, bool no_case = false>
+        struct make_char_class : mpl::identity<Tag> {};
+        template <>
+        struct make_char_class<tag::lower, true> : mpl::identity<tag::alpha> {};
+        template <>
+        struct make_char_class<tag::upper, true> : mpl::identity<tag::alpha> {};
+    }
+    template <typename CharClass, typename CharEncoding, typename Modifiers>
+    struct make_primitive<tag::char_code<CharClass, CharEncoding>, Modifiers>
+    {
+        static bool const no_case =
+            has_modifier<Modifiers, tag::char_code_base<tag::no_case> >::value;
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef tag::char_code<
+            typename detail::make_char_class<CharClass, no_case>::type
+          , char_encoding>
+        tag;
+        typedef char_class<tag> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::lit, 1>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit
+{
+    template <typename CharEncoding>
+    struct use_terminal<qi::domain
+      , terminal<
+            tag::char_code<tag::char_, CharEncoding>
+        >
+    > : mpl::true_ {};
+    template <typename CharEncoding, typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<A0>
+        >
+    > : mpl::true_ {};
+    template <typename CharEncoding, typename A0, typename A1>
+    struct use_terminal<qi::domain
+      , terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<A0, A1>
+        >
+    > : mpl::true_ {};
+    template <typename CharEncoding>
+    struct use_lazy_terminal<
+        qi::domain
+      , tag::char_code<tag::char_, CharEncoding>
+      , 1
+    > : mpl::true_ {};
+    template <typename CharEncoding>
+    struct use_lazy_terminal<
+        qi::domain
+      , tag::char_code<tag::char_, CharEncoding>
+      , 2
+    > : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, char>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, char[2]>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, wchar_t>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, wchar_t[2]>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+          , terminal_ex<tag::lit, fusion::vector1<A0> >
+          , typename enable_if<traits::is_char<A0> >::type>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::lit;
+    using spirit::lit_type;
+    template <typename CharEncoding, bool no_attribute, bool no_case = false>
+    struct literal_char
+      : char_parser<
+            literal_char<CharEncoding, no_attribute, false>
+          , typename CharEncoding::char_type
+          , typename mpl::if_c<no_attribute, unused_type
+              , typename CharEncoding::char_type>::type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        template <typename Char>
+        literal_char(Char ch)
+          : ch(static_cast<char_type>(ch)) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename mpl::if_c<
+                no_attribute, unused_type, char_type>::type
+            type;
+        };
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch_, Context&) const
+        {
+            return traits::ischar<CharParam, char_encoding>::call(ch_) &&
+                   ch == char_type(ch_);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("literal-char", char_encoding::toucs4(ch));
+        }
+        char_type ch;
+    };
+    template <typename CharEncoding, bool no_attribute>
+    struct literal_char<CharEncoding, no_attribute, true>
+      : char_parser<
+            literal_char<CharEncoding, no_attribute, true>
+          , typename mpl::if_c<no_attribute, unused_type
+              , typename CharEncoding::char_type>::type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        literal_char(char_type ch)
+          : lo(static_cast<char_type>(char_encoding::tolower(ch)))
+          , hi(static_cast<char_type>(char_encoding::toupper(ch))) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename mpl::if_c<
+                no_attribute, unused_type, char_type>::type
+            type;
+        };
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch_, Context&) const
+        {
+            if (!traits::ischar<CharParam, char_encoding>::call(ch_))
+                return false;
+            char_type ch = char_type(ch_);
+            return this->lo == ch || this->hi == ch;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("no-case-literal-char", char_encoding::toucs4(lo));
+        }
+        char_type lo, hi;
+    };
+    template <typename CharEncoding, bool no_case = false>
+    struct char_range
+      : char_parser<char_range<CharEncoding, false>, typename CharEncoding::char_type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        char_range(char_type from, char_type to)
+          : from(from), to(to) {}
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch_, Context&) const
+        {
+            if (!traits::ischar<CharParam, char_encoding>::call(ch_))
+                return false;
+            char_type ch = char_type(ch_);
+            return !(ch < from) && !(to < ch);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            info result("char-range", char_encoding::toucs4(from));
+            boost::get<std::string>(result.value) += '-';
+            boost::get<std::string>(result.value) += to_utf8(char_encoding::toucs4(to));
+            return result;
+        }
+        char_type from, to;
+    };
+    template <typename CharEncoding>
+    struct char_range<CharEncoding, true>
+      : char_parser<char_range<CharEncoding, true>, typename CharEncoding::char_type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        char_range(char_type from, char_type to)
+          : from_lo(static_cast<char_type>(char_encoding::tolower(from)))
+          , to_lo(static_cast<char_type>(char_encoding::tolower(to)))
+          , from_hi(static_cast<char_type>(char_encoding::toupper(from)))
+          , to_hi(static_cast<char_type>(char_encoding::toupper(to)))
+        {}
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch_, Context&) const
+        {
+            if (!traits::ischar<CharParam, char_encoding>::call(ch_))
+                return false;
+            char_type ch = char_type(ch_);
+            return (!(ch < from_lo) && !(to_lo < ch))
+                || (!(ch < from_hi) && !(to_hi < ch))
+            ;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            info result("no-case-char-range", char_encoding::toucs4(from_lo));
+            boost::get<std::string>(result.value) += '-';
+            boost::get<std::string>(result.value) += to_utf8(char_encoding::toucs4(to_lo));
+            return result;
+        }
+        char_type from_lo, to_lo, from_hi, to_hi;
+    };
+    template <typename CharEncoding, bool no_attribute, bool no_case = false>
+    struct char_set
+      : char_parser<char_set<CharEncoding, no_attribute, false>
+          , typename mpl::if_c<no_attribute, unused_type
+              , typename CharEncoding::char_type>::type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        template <typename String>
+        char_set(String const& str)
+        {
+            using spirit::detail::cast_char;
+            typedef typename
+                remove_const<
+                    typename traits::char_type_of<String>::type
+                >::type
+            in_type;
+            struct cannot_convert_string; typedef struct
+ cannot_convert_string292
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (cannot_convert_string::************ assert_arg()) (String) { return 0; } }
+ mpl_assert_arg292
+            ; enum { mpl_assertion_in_line_292 = sizeof( boost::mpl::assertion_failed<(( (sizeof(char_type) >= sizeof(in_type)) ))>( mpl_assert_arg292::assert_arg() ) ) }
+                                               ;
+            in_type const* definition =
+                (in_type const*)traits::get_c_string(str);
+            in_type ch = *definition++;
+            while (ch)
+            {
+                in_type next = *definition++;
+                if (next == '-')
+                {
+                    next = *definition++;
+                    if (next == 0)
+                    {
+                        chset.set(cast_char<char_type>(ch));
+                        chset.set('-');
+                        break;
+                    }
+                    chset.set(
+                        cast_char<char_type>(ch),
+                        cast_char<char_type>(next)
+                    );
+                }
+                else
+                {
+                    chset.set(cast_char<char_type>(ch));
+                }
+                ch = next;
+            }
+        }
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch, Context&) const
+        {
+            return traits::ischar<CharParam, char_encoding>::call(ch) &&
+                   chset.test(char_type(ch));
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("char-set");
+        }
+        support::detail::basic_chset<char_type> chset;
+    };
+    template <typename CharEncoding, bool no_attribute>
+    struct char_set<CharEncoding, no_attribute, true>
+      : char_parser<char_set<CharEncoding, no_attribute, true>
+          , typename mpl::if_c<no_attribute, unused_type
+              , typename CharEncoding::char_type>::type>
+    {
+        typedef typename CharEncoding::char_type char_type;
+        typedef CharEncoding char_encoding;
+        template <typename String>
+        char_set(String const& str)
+        {
+            typedef typename traits::char_type_of<String>::type in_type;
+            struct cannot_convert_string; typedef struct
+ cannot_convert_string354
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (cannot_convert_string::************ assert_arg()) (String) { return 0; } }
+ mpl_assert_arg354
+            ; enum { mpl_assertion_in_line_354 = sizeof( boost::mpl::assertion_failed<(( (sizeof(char_type) == sizeof(in_type)) ))>( mpl_assert_arg354::assert_arg() ) ) }
+                                               ;
+            char_type const* definition =
+                (char_type const*)traits::get_c_string(str);
+            char_type ch = *definition++;
+            while (ch)
+            {
+                char_type next = *definition++;
+                if (next == '-')
+                {
+                    next = *definition++;
+                    if (next == 0)
+                    {
+                        chset.set(static_cast<char_type>(CharEncoding::tolower(ch)));
+                        chset.set(static_cast<char_type>(CharEncoding::toupper(ch)));
+                        chset.set('-');
+                        break;
+                    }
+                    chset.set(static_cast<char_type>(CharEncoding::tolower(ch))
+                      , static_cast<char_type>(CharEncoding::tolower(next)));
+                    chset.set(static_cast<char_type>(CharEncoding::toupper(ch))
+                      , static_cast<char_type>(CharEncoding::toupper(next)));
+                }
+                else
+                {
+                    chset.set(static_cast<char_type>(CharEncoding::tolower(ch)));
+                    chset.set(static_cast<char_type>(CharEncoding::toupper(ch)));
+                }
+                ch = next;
+            }
+        }
+        template <typename CharParam, typename Context>
+        bool test(CharParam ch, Context&) const
+        {
+            return traits::ischar<CharParam, char_encoding>::call(ch) &&
+                   chset.test(char_type(ch));
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("no-case-char-set");
+        }
+        support::detail::basic_chset<char_type> chset;
+    };
+    namespace detail
+    {
+        template <typename Modifiers, typename Encoding>
+        struct basic_literal
+        {
+            static bool const no_case =
+                has_modifier<
+                    Modifiers
+                  , tag::char_code_base<tag::no_case>
+                >::value;
+            static bool const no_attr =
+                !has_modifier<
+                    Modifiers
+                  , tag::lazy_eval
+                >::value;
+            typedef literal_char<
+                typename spirit::detail::get_encoding_with_case<
+                    Modifiers, Encoding, no_case>::type
+              , no_attr
+              , no_case>
+            result_type;
+            template <typename Char>
+            result_type operator()(Char ch, unused_type) const
+            {
+                return result_type(ch);
+            }
+            template <typename Char>
+            result_type operator()(Char const* str, unused_type) const
+            {
+                return result_type(str[0]);
+            }
+        };
+    }
+    template <typename Modifiers>
+    struct make_primitive<char, Modifiers>
+      : detail::basic_literal<Modifiers, char_encoding::standard> {};
+    template <typename Modifiers>
+    struct make_primitive<char const(&)[2], Modifiers>
+      : detail::basic_literal<Modifiers, char_encoding::standard> {};
+    template <typename Modifiers>
+    struct make_primitive<wchar_t, Modifiers>
+      : detail::basic_literal<Modifiers, char_encoding::standard_wide> {};
+    template <typename Modifiers>
+    struct make_primitive<wchar_t const(&)[2], Modifiers>
+      : detail::basic_literal<Modifiers, char_encoding::standard_wide> {};
+    template <typename CharEncoding, typename Modifiers>
+    struct make_primitive<
+        terminal<tag::char_code<tag::char_, CharEncoding> >, Modifiers>
+    {
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef tag::char_code<tag::char_, char_encoding> tag;
+        typedef char_class<tag> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename CharEncoding, typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<A0> >
+      , Modifiers>
+    {
+        static bool const no_case =
+            has_modifier<Modifiers, tag::char_code_base<tag::no_case> >::value;
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef typename
+            mpl::if_<
+                traits::is_string<A0>
+              , char_set<char_encoding, false, no_case>
+              , literal_char<char_encoding, false, no_case>
+            >::type
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::lit, fusion::vector1<A0> >
+      , Modifiers
+      , typename enable_if<traits::is_char<A0> >::type>
+    {
+        static bool const no_case =
+            has_modifier<
+                Modifiers
+              , tag::char_code_base<tag::no_case>
+            >::value;
+        typedef typename traits::char_encoding_from_char<
+                typename traits::char_type_of<A0>::type>::type encoding;
+        typedef literal_char<
+            typename spirit::detail::get_encoding_with_case<
+                Modifiers, encoding, no_case>::type
+          , true, no_case>
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename CharEncoding, typename Modifiers, typename Char>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector1<Char(&)[2]>
+        >
+      , Modifiers>
+    {
+        static bool const no_case =
+            has_modifier<Modifiers, tag::char_code_base<tag::no_case> >::value;
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef literal_char<char_encoding, false, no_case> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args)[0]);
+        }
+    };
+    template <typename CharEncoding, typename Modifiers, typename A0, typename A1>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<A0, A1>
+        >
+      , Modifiers>
+    {
+        static bool const no_case =
+            has_modifier<Modifiers, tag::char_code_base<tag::no_case> >::value;
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef char_range<char_encoding, no_case> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)
+              , fusion::at_c<1>(term.args)
+            );
+        }
+    };
+    template <typename CharEncoding, typename Modifiers, typename Char>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::char_, CharEncoding>
+          , fusion::vector2<Char(&)[2], Char(&)[2]>
+        >
+      , Modifiers>
+    {
+        static bool const no_case =
+            has_modifier<Modifiers, tag::char_code_base<tag::no_case> >::value;
+        typedef typename
+            spirit::detail::get_encoding<Modifiers, CharEncoding>::type
+        char_encoding;
+        typedef char_range<char_encoding, no_case> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(
+                fusion::at_c<0>(term.args)[0]
+              , fusion::at_c<1>(term.args)[0]
+            );
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+  namespace endian
+  {
+    template <typename T, typename IntegerType>
+    class cover_operators
+    {
+      friend IntegerType operator+(const T& x) { return x; }
+      friend T& operator+=(T& x, IntegerType y) { return x = +x + y; }
+      friend T& operator-=(T& x, IntegerType y) { return x = +x - y; }
+      friend T& operator*=(T& x, IntegerType y) { return x = +x * y; }
+      friend T& operator/=(T& x, IntegerType y) { return x = +x / y; }
+      friend T& operator%=(T& x, IntegerType y) { return x = +x % y; }
+      friend T& operator&=(T& x, IntegerType y) { return x = +x & y; }
+      friend T& operator|=(T& x, IntegerType y) { return x = +x | y; }
+      friend T& operator^=(T& x, IntegerType y) { return x = +x ^ y; }
+      friend T& operator<<=(T& x, IntegerType y) { return x = +x << y; }
+      friend T& operator>>=(T& x, IntegerType y) { return x = +x >> y; }
+      friend IntegerType operator<<(const T& x, IntegerType y) { return +x << y; }
+      friend IntegerType operator>>(const T& x, IntegerType y) { return +x >> y; }
+      friend T& operator++(T& x) { return x += 1; }
+      friend T& operator--(T& x) { return x -= 1; }
+      friend T operator++(T& x, int)
+      {
+        T tmp(x);
+        x += 1;
+        return tmp;
+      }
+      friend T operator--(T& x, int)
+      {
+        T tmp(x);
+        x -= 1;
+        return tmp;
+      }
+    };
+  }
+}}
+namespace boost { namespace spirit
+{
+  namespace detail
+  {
+    template <typename T, std::size_t n_bytes,
+      bool sign=boost::is_signed<T>::value >
+    struct unrolled_byte_loops
+    {
+      typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
+      static T load_big(const unsigned char* bytes)
+        { return *(bytes - 1) | (next::load_big(bytes - 1) << 8); }
+      static T load_little(const unsigned char* bytes)
+        { return *bytes | (next::load_little(bytes + 1) << 8); }
+      static void store_big(char* bytes, T value)
+        {
+          *(bytes - 1) = static_cast<char>(value);
+          next::store_big(bytes - 1, value >> 8);
+        }
+      static void store_little(char* bytes, T value)
+        {
+          *bytes = static_cast<char>(value);
+          next::store_little(bytes + 1, value >> 8);
+        }
+    };
+    template <typename T>
+    struct unrolled_byte_loops<T, 1, false>
+    {
+      static T load_big(const unsigned char* bytes)
+        { return *(bytes - 1); }
+      static T load_little(const unsigned char* bytes)
+        { return *bytes; }
+      static void store_big(char* bytes, T value)
+        { *(bytes - 1) = static_cast<char>(value); }
+      static void store_little(char* bytes, T value)
+        { *bytes = static_cast<char>(value); }
+    };
+    template <typename T>
+    struct unrolled_byte_loops<T, 1, true>
+    {
+      static T load_big(const unsigned char* bytes)
+        { return *reinterpret_cast<const signed char*>(bytes - 1); }
+      static T load_little(const unsigned char* bytes)
+        { return *reinterpret_cast<const signed char*>(bytes); }
+      static void store_big(char* bytes, T value)
+        { *(bytes - 1) = static_cast<char>(value); }
+      static void store_little(char* bytes, T value)
+        { *bytes = static_cast<char>(value); }
+    };
+    template <typename T, std::size_t n_bytes>
+    inline
+    T load_big_endian(const void* bytes)
+    {
+      return unrolled_byte_loops<T, n_bytes>::load_big
+        (static_cast<const unsigned char*>(bytes) + n_bytes);
+    }
+    template <>
+    inline
+    float load_big_endian<float, 4>(const void* bytes)
+    {
+        const unsigned char *b = reinterpret_cast<const unsigned char *>(
+            bytes);
+        b += 3;
+        float value;
+        unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+        for(std::size_t i = 0; i < 4; ++i)
+        {
+            *v++ = *b--;
+        }
+        return value;
+    }
+    template <>
+    inline
+    double load_big_endian<double, 8>(const void* bytes)
+    {
+        const unsigned char *b = reinterpret_cast<const unsigned char *>(
+            bytes);
+        b += 7;
+        double value;
+        unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+        for(std::size_t i = 0; i < 8; ++i)
+        {
+            *v++ = *b--;
+        }
+        return value;
+    }
+    template <typename T, std::size_t n_bytes>
+    inline
+    T load_little_endian(const void* bytes)
+    {
+      return unrolled_byte_loops<T, n_bytes>::load_little
+        (static_cast<const unsigned char*>(bytes));
+    }
+    template <>
+    inline
+    float load_little_endian<float, 4>(const void* bytes)
+    {
+        const unsigned char *b = reinterpret_cast<const unsigned char *>(
+            bytes);
+        float value;
+        unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+        for(std::size_t i = 0; i < 4; ++i)
+        {
+            *v++ = *b++;
+        }
+        return value;
+    }
+    template <>
+    inline
+    double load_little_endian<double, 8>(const void* bytes)
+    {
+        const unsigned char *b = reinterpret_cast<const unsigned char *>(
+            bytes);
+        double value;
+        unsigned char *v = reinterpret_cast<unsigned char *>(&value);
+        for(std::size_t i = 0; i < 8; ++i)
+        {
+            *v++ = *b++;
+        }
+        return value;
+    }
+    template <typename T, std::size_t n_bytes>
+    inline
+    void store_big_endian(void* bytes, T value)
+    {
+      unrolled_byte_loops<T, n_bytes>::store_big
+        (static_cast<char*>(bytes) + n_bytes, value);
+    }
+    template <>
+    inline
+    void store_big_endian<float, 4>(void* bytes, float value)
+    {
+        unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+        b += 3;
+        const unsigned char *v = reinterpret_cast<const unsigned char *>(
+            &value);
+        for(std::size_t i = 0; i < 4; ++i)
+        {
+            *b-- = *v++;
+        }
+    }
+    template <>
+    inline
+    void store_big_endian<double, 8>(void* bytes, double value)
+    {
+        unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+        b += 7;
+        const unsigned char *v = reinterpret_cast<const unsigned char *>(
+            &value);
+        for(std::size_t i = 0; i < 8; ++i)
+        {
+            *b-- = *v++;
+        }
+    }
+    template <typename T, std::size_t n_bytes>
+    inline
+    void store_little_endian(void* bytes, T value)
+    {
+      unrolled_byte_loops<T, n_bytes>::store_little
+        (static_cast<char*>(bytes), value);
+    }
+    template <>
+    inline
+    void store_little_endian<float, 4>(void* bytes, float value)
+    {
+        unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+        const unsigned char *v = reinterpret_cast<const unsigned char *>(
+            &value);
+        for(std::size_t i = 0; i < 4; ++i)
+        {
+            *b++ = *v++;
+        }
+    }
+    template <>
+    inline
+    void store_little_endian<double, 8>(void* bytes, double value)
+    {
+        unsigned char *b = reinterpret_cast<unsigned char *>(bytes);
+        const unsigned char *v = reinterpret_cast<const unsigned char *>(
+            &value);
+        for(std::size_t i = 0; i < 8; ++i)
+        {
+            *b++ = *v++;
+        }
+    }
+  }
+  namespace endian
+  {
+  struct endianness { enum enum_type { big, little, native }; };
+  struct alignment { enum enum_type { unaligned, aligned }; };
+  template <endianness::enum_type E, typename T, std::size_t n_bits,
+    alignment::enum_type A = alignment::unaligned>
+    class endian;
+    template <typename T, std::size_t n_bits>
+    class endian< endianness::big, T, n_bits, alignment::unaligned >
+      : cover_operators< endian< endianness::big, T, n_bits >, T >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((n_bits/8)*8 == n_bits) == 0 ? false : true) >)> boost_static_assert_typedef_314;
+      public:
+        typedef T value_type;
+        endian & operator=(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); return *this; }
+        operator T() const
+        {
+          return detail::load_big_endian<T, n_bits/8>(m_value);
+        }
+      private:
+        char m_value[n_bits/8];
+    };
+    template <typename T, std::size_t n_bits>
+    class endian< endianness::little, T, n_bits, alignment::unaligned >
+      : cover_operators< endian< endianness::little, T, n_bits >, T >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((n_bits/8)*8 == n_bits) == 0 ? false : true) >)> boost_static_assert_typedef_346;
+      public:
+        typedef T value_type;
+        endian & operator=(T val) { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
+        operator T() const
+        {
+          return detail::load_little_endian<T, n_bits/8>(m_value);
+        }
+      private:
+        char m_value[n_bits/8];
+    };
+    template <typename T, std::size_t n_bits>
+    class endian< endianness::native, T, n_bits, alignment::unaligned >
+      : cover_operators< endian< endianness::native, T, n_bits >, T >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((n_bits/8)*8 == n_bits) == 0 ? false : true) >)> boost_static_assert_typedef_378;
+      public:
+        typedef T value_type;
+        endian & operator=(T val) { detail::store_big_endian<T, n_bits/8>(m_value, val); return *this; }
+        operator T() const { return detail::load_big_endian<T, n_bits/8>(m_value); }
+      private:
+        char m_value[n_bits/8];
+    };
+    template <typename T, std::size_t n_bits>
+    class endian< endianness::big, T, n_bits, alignment::aligned >
+      : cover_operators< endian< endianness::big, T, n_bits, alignment::aligned >, T >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((n_bits/8)*8 == n_bits) == 0 ? false : true) >)> boost_static_assert_typedef_408;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(T) == n_bits/8) == 0 ? false : true) >)> boost_static_assert_typedef_409;
+      public:
+        typedef T value_type;
+        endian & operator=(T val) { m_value = val; return *this; }
+        operator T() const { return m_value; }
+      private:
+        T m_value;
+    };
+    template <typename T, std::size_t n_bits>
+    class endian< endianness::little, T, n_bits, alignment::aligned >
+      : cover_operators< endian< endianness::little, T, n_bits, alignment::aligned >, T >
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((n_bits/8)*8 == n_bits) == 0 ? false : true) >)> boost_static_assert_typedef_436;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(T) == n_bits/8) == 0 ? false : true) >)> boost_static_assert_typedef_437;
+      public:
+        typedef T value_type;
+        endian & operator=(T val) { detail::store_little_endian<T, sizeof(T)>(&m_value, val); return *this; }
+        operator T() const { return detail::load_little_endian<T, sizeof(T)>(&m_value); }
+      private:
+        T m_value;
+    };
+    typedef endian< endianness::big, int_least8_t, 8 > big8_t;
+    typedef endian< endianness::big, int_least16_t, 16 > big16_t;
+    typedef endian< endianness::big, int_least32_t, 24 > big24_t;
+    typedef endian< endianness::big, int_least32_t, 32 > big32_t;
+    typedef endian< endianness::big, int_least64_t, 40 > big40_t;
+    typedef endian< endianness::big, int_least64_t, 48 > big48_t;
+    typedef endian< endianness::big, int_least64_t, 56 > big56_t;
+    typedef endian< endianness::big, int_least64_t, 64 > big64_t;
+    typedef endian< endianness::big, uint_least8_t, 8 > ubig8_t;
+    typedef endian< endianness::big, uint_least16_t, 16 > ubig16_t;
+    typedef endian< endianness::big, uint_least32_t, 24 > ubig24_t;
+    typedef endian< endianness::big, uint_least32_t, 32 > ubig32_t;
+    typedef endian< endianness::big, uint_least64_t, 40 > ubig40_t;
+    typedef endian< endianness::big, uint_least64_t, 48 > ubig48_t;
+    typedef endian< endianness::big, uint_least64_t, 56 > ubig56_t;
+    typedef endian< endianness::big, uint_least64_t, 64 > ubig64_t;
+    typedef endian< endianness::little, int_least8_t, 8 > little8_t;
+    typedef endian< endianness::little, int_least16_t, 16 > little16_t;
+    typedef endian< endianness::little, int_least32_t, 24 > little24_t;
+    typedef endian< endianness::little, int_least32_t, 32 > little32_t;
+    typedef endian< endianness::little, int_least64_t, 40 > little40_t;
+    typedef endian< endianness::little, int_least64_t, 48 > little48_t;
+    typedef endian< endianness::little, int_least64_t, 56 > little56_t;
+    typedef endian< endianness::little, int_least64_t, 64 > little64_t;
+    typedef endian< endianness::little, uint_least8_t, 8 > ulittle8_t;
+    typedef endian< endianness::little, uint_least16_t, 16 > ulittle16_t;
+    typedef endian< endianness::little, uint_least32_t, 24 > ulittle24_t;
+    typedef endian< endianness::little, uint_least32_t, 32 > ulittle32_t;
+    typedef endian< endianness::little, uint_least64_t, 40 > ulittle40_t;
+    typedef endian< endianness::little, uint_least64_t, 48 > ulittle48_t;
+    typedef endian< endianness::little, uint_least64_t, 56 > ulittle56_t;
+    typedef endian< endianness::little, uint_least64_t, 64 > ulittle64_t;
+    typedef endian< endianness::native, int_least8_t, 8 > native8_t;
+    typedef endian< endianness::native, int_least16_t, 16 > native16_t;
+    typedef endian< endianness::native, int_least32_t, 24 > native24_t;
+    typedef endian< endianness::native, int_least32_t, 32 > native32_t;
+    typedef endian< endianness::native, int_least64_t, 40 > native40_t;
+    typedef endian< endianness::native, int_least64_t, 48 > native48_t;
+    typedef endian< endianness::native, int_least64_t, 56 > native56_t;
+    typedef endian< endianness::native, int_least64_t, 64 > native64_t;
+    typedef endian< endianness::native, uint_least8_t, 8 > unative8_t;
+    typedef endian< endianness::native, uint_least16_t, 16 > unative16_t;
+    typedef endian< endianness::native, uint_least32_t, 24 > unative24_t;
+    typedef endian< endianness::native, uint_least32_t, 32 > unative32_t;
+    typedef endian< endianness::native, uint_least64_t, 40 > unative40_t;
+    typedef endian< endianness::native, uint_least64_t, 48 > unative48_t;
+    typedef endian< endianness::native, uint_least64_t, 56 > unative56_t;
+    typedef endian< endianness::native, uint_least64_t, 64 > unative64_t;
+    typedef endian< endianness::big, int16_t, 16, alignment::aligned > aligned_big16_t;
+    typedef endian< endianness::big, uint16_t, 16, alignment::aligned > aligned_ubig16_t;
+    typedef endian< endianness::little, int16_t, 16, alignment::aligned > aligned_little16_t;
+    typedef endian< endianness::little, uint16_t, 16, alignment::aligned > aligned_ulittle16_t;
+    typedef endian< endianness::big, int32_t, 32, alignment::aligned > aligned_big32_t;
+    typedef endian< endianness::big, uint32_t, 32, alignment::aligned > aligned_ubig32_t;
+    typedef endian< endianness::little, int32_t, 32, alignment::aligned > aligned_little32_t;
+    typedef endian< endianness::little, uint32_t, 32, alignment::aligned > aligned_ulittle32_t;
+    typedef endian< endianness::big, int64_t, 64, alignment::aligned > aligned_big64_t;
+    typedef endian< endianness::big, uint64_t, 64, alignment::aligned > aligned_ubig64_t;
+    typedef endian< endianness::little, int64_t, 64, alignment::aligned > aligned_little64_t;
+    typedef endian< endianness::little, uint64_t, 64, alignment::aligned > aligned_ulittle64_t;
+  }
+}}
+namespace boost { namespace endian
+{
+    using namespace boost::spirit::endian;
+}}
+namespace boost {
+template< typename T > struct is_floating_point : public ::boost::integral_constant<bool,false> { public: };
+template<> struct is_floating_point< float > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< float const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_floating_point< double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< double const volatile > : public ::boost::integral_constant<bool,true> { public: };
+template<> struct is_floating_point< long double > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double const > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double volatile > : public ::boost::integral_constant<bool,true> { public: }; template<> struct is_floating_point< long double const volatile > : public ::boost::integral_constant<bool,true> { public: };
+}
+namespace boost { namespace spirit
+{
+    template <> struct use_terminal<qi::domain, tag::byte_> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::byte_, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::byte_, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::word> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::word, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::word, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::big_word> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::big_word, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::big_word, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::little_word> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::little_word, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::little_word, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::dword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::dword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::dword, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::big_dword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::big_dword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::big_dword, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::little_dword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::little_dword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::little_dword, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::qword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::qword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::qword, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::big_qword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::big_qword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::big_qword, 1> : mpl::true_ {};
+    template <> struct use_terminal<qi::domain, tag::little_qword> : mpl::true_ {}; template <typename A0> struct use_terminal<qi::domain , terminal_ex<tag::little_qword, fusion::vector1<A0> > > : mpl::or_<is_integral<A0>, is_enum<A0> > {}; template <> struct use_lazy_terminal<qi::domain, tag::little_qword, 1> : mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::bin_float>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::bin_float, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::bin_float, 1>: mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::big_bin_float>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::big_bin_float, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::big_bin_float, 1>: mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::little_bin_float>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::little_bin_float, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::little_bin_float, 1>: mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::bin_double>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::bin_double, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::bin_double, 1>: mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::big_bin_double>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::big_bin_double, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::big_bin_double, 1>: mpl::true_ {};
+    template<> struct use_terminal<qi::domain, tag::little_bin_double>: mpl::true_ {}; template<typename A0> struct use_terminal<qi::domain, terminal_ex<tag::little_bin_double, fusion::vector1<A0> > >: is_floating_point<A0> {}; template<> struct use_lazy_terminal<qi::domain, tag::little_bin_double, 1>: mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using boost::spirit::byte_;
+    using boost::spirit::word;
+    using boost::spirit::big_word;
+    using boost::spirit::little_word;
+    using boost::spirit::dword;
+    using boost::spirit::big_dword;
+    using boost::spirit::little_dword;
+    using boost::spirit::qword;
+    using boost::spirit::big_qword;
+    using boost::spirit::little_qword;
+    using boost::spirit::bin_float;
+    using boost::spirit::big_bin_float;
+    using boost::spirit::little_bin_float;
+    using boost::spirit::bin_double;
+    using boost::spirit::big_bin_double;
+    using boost::spirit::little_bin_double;
+    using boost::spirit::byte_type;
+    using boost::spirit::word_type;
+    using boost::spirit::big_word_type;
+    using boost::spirit::little_word_type;
+    using boost::spirit::dword_type;
+    using boost::spirit::big_dword_type;
+    using boost::spirit::little_dword_type;
+    using boost::spirit::qword_type;
+    using boost::spirit::big_qword_type;
+    using boost::spirit::little_qword_type;
+    using boost::spirit::bin_float_type;
+    using boost::spirit::big_bin_float_type;
+    using boost::spirit::little_bin_float_type;
+    using boost::spirit::bin_double_type;
+    using boost::spirit::big_bin_double_type;
+    using boost::spirit::little_bin_double_type;
+    namespace detail
+    {
+        template <int bits>
+        struct integer
+        {
+            struct not_supported_binary_size; typedef struct
+ not_supported_binary_size137
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_binary_size::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg137
+            ; enum { mpl_assertion_in_line_137 = sizeof( boost::mpl::assertion_failed<(bits == 8 || bits == 16 || bits == 32 || bits == 64)>( mpl_assert_arg137::assert_arg() ) ) }
+                                              ;
+        };
+        template <>
+        struct integer<8>
+        {
+            enum { size = 1 };
+            typedef uint_least8_t type;
+        };
+        template <>
+        struct integer<16>
+        {
+            enum { size = 2 };
+            typedef uint_least16_t type;
+        };
+        template <>
+        struct integer<32>
+        {
+            enum { size = 4 };
+            typedef uint_least32_t type;
+        };
+        template <>
+        struct integer<64>
+        {
+            enum { size = 8 };
+            typedef uint_least64_t type;
+        };
+        template <int bits>
+        struct floating_point
+        {
+            struct not_supported_binary_size; typedef struct
+ not_supported_binary_size180
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_binary_size::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg180
+            ; enum { mpl_assertion_in_line_180 = sizeof( boost::mpl::assertion_failed<(bits == 32 || bits == 64)>( mpl_assert_arg180::assert_arg() ) ) }
+                                              ;
+        };
+        template <>
+        struct floating_point<32>
+        {
+            enum { size = 4 };
+            typedef float type;
+        };
+        template <>
+        struct floating_point<64>
+        {
+            enum { size = 8 };
+            typedef double type;
+        };
+        template <boost::endian::endianness::enum_type bits>
+        struct what;
+        template <>
+        struct what<boost::endian::endianness::native>
+        {
+            static std::string is()
+            {
+                return "native-endian binary";
+            }
+        };
+        template <>
+        struct what<boost::endian::endianness::little>
+        {
+            static char const* is()
+            {
+                return "little-endian binary";
+            }
+        };
+        template <>
+        struct what<boost::endian::endianness::big>
+        {
+            static char const* is()
+            {
+                return "big-endian binary";
+            }
+        };
+    }
+    template <typename T, boost::endian::endianness::enum_type endian, int bits>
+    struct any_binary_parser : primitive_parser<any_binary_parser<T, endian, bits> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef boost::endian::endian<endian, typename T::type,
+                bits> type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            typename attribute<Context, Iterator>::type attr_;
+            unsigned char* bytes = reinterpret_cast<unsigned char*>(&attr_);
+            Iterator it = first;
+            for (unsigned int i = 0; i < sizeof(attr_); ++i)
+            {
+                if (it == last)
+                    return false;
+                *bytes++ = *it++;
+            }
+            first = it;
+            spirit::traits::assign_to(attr_, attr);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info(qi::detail::what<endian>::is());
+        }
+    };
+    template <typename V, typename T
+      , boost::endian::endianness::enum_type endian, int bits>
+    struct binary_lit_parser
+      : primitive_parser<binary_lit_parser<V, T, endian, bits> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        binary_lit_parser(V n)
+          : n(n) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            boost::endian::endian<endian, typename T::type, bits> attr_;
+            attr_ = n;
+            unsigned char* bytes = reinterpret_cast<unsigned char*>(&attr_);
+            Iterator it = first;
+            for (unsigned int i = 0; i < sizeof(attr_); ++i)
+            {
+                if (it == last || *bytes++ != static_cast<unsigned char>(*it++))
+                    return false;
+            }
+            first = it;
+            spirit::traits::assign_to(attr_, attr);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info(qi::detail::what<endian>::is());
+        }
+        V n;
+    };
+    template <typename T, boost::endian::endianness::enum_type endian, int bits>
+    struct make_binary_parser
+    {
+        typedef any_binary_parser<T, endian, bits> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename V, typename T
+      , boost::endian::endianness::enum_type endian, int bits>
+    struct make_binary_lit_parser
+    {
+        typedef binary_lit_parser<V, T, endian, bits> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers> struct make_primitive<tag::byte_, Modifiers> : make_binary_parser<detail::integer<8>, boost::endian::endianness::native, 8> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::byte_, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<8>, boost::endian::endianness::native, 8> {};
+    template <typename Modifiers> struct make_primitive<tag::word, Modifiers> : make_binary_parser<detail::integer<16>, boost::endian::endianness::native, 16> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::word, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<16>, boost::endian::endianness::native, 16> {};
+    template <typename Modifiers> struct make_primitive<tag::big_word, Modifiers> : make_binary_parser<detail::integer<16>, boost::endian::endianness::big, 16> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::big_word, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<16>, boost::endian::endianness::big, 16> {};
+    template <typename Modifiers> struct make_primitive<tag::little_word, Modifiers> : make_binary_parser<detail::integer<16>, boost::endian::endianness::little, 16> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::little_word, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<16>, boost::endian::endianness::little, 16> {};
+    template <typename Modifiers> struct make_primitive<tag::dword, Modifiers> : make_binary_parser<detail::integer<32>, boost::endian::endianness::native, 32> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::dword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<32>, boost::endian::endianness::native, 32> {};
+    template <typename Modifiers> struct make_primitive<tag::big_dword, Modifiers> : make_binary_parser<detail::integer<32>, boost::endian::endianness::big, 32> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::big_dword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<32>, boost::endian::endianness::big, 32> {};
+    template <typename Modifiers> struct make_primitive<tag::little_dword, Modifiers> : make_binary_parser<detail::integer<32>, boost::endian::endianness::little, 32> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::little_dword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<32>, boost::endian::endianness::little, 32> {};
+    template <typename Modifiers> struct make_primitive<tag::qword, Modifiers> : make_binary_parser<detail::integer<64>, boost::endian::endianness::native, 64> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::qword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<64>, boost::endian::endianness::native, 64> {};
+    template <typename Modifiers> struct make_primitive<tag::big_qword, Modifiers> : make_binary_parser<detail::integer<64>, boost::endian::endianness::big, 64> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::big_qword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<64>, boost::endian::endianness::big, 64> {};
+    template <typename Modifiers> struct make_primitive<tag::little_qword, Modifiers> : make_binary_parser<detail::integer<64>, boost::endian::endianness::little, 64> {}; template <typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::little_qword, fusion::vector1<A0> > , Modifiers> : make_binary_lit_parser<A0, detail::integer<64>, boost::endian::endianness::little, 64> {};
+    template<typename Modifiers> struct make_primitive<tag::bin_float, Modifiers> : make_binary_parser<detail::floating_point<32>, boost::endian::endianness::native, 32> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::bin_float, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<32>, boost::endian::endianness::native, 32> {};
+    template<typename Modifiers> struct make_primitive<tag::big_bin_float, Modifiers> : make_binary_parser<detail::floating_point<32>, boost::endian::endianness::big, 32> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::big_bin_float, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<32>, boost::endian::endianness::big, 32> {};
+    template<typename Modifiers> struct make_primitive<tag::little_bin_float, Modifiers> : make_binary_parser<detail::floating_point<32>, boost::endian::endianness::little, 32> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::little_bin_float, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<32>, boost::endian::endianness::little, 32> {};
+    template<typename Modifiers> struct make_primitive<tag::bin_double, Modifiers> : make_binary_parser<detail::floating_point<64>, boost::endian::endianness::native, 64> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::bin_double, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<64>, boost::endian::endianness::native, 64> {};
+    template<typename Modifiers> struct make_primitive<tag::big_bin_double, Modifiers> : make_binary_parser<detail::floating_point<64>, boost::endian::endianness::big, 64> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::big_bin_double, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<64>, boost::endian::endianness::big, 64> {};
+    template<typename Modifiers> struct make_primitive<tag::little_bin_double, Modifiers> : make_binary_parser<detail::floating_point<64>, boost::endian::endianness::little, 64> {}; template<typename Modifiers, typename A0> struct make_primitive< terminal_ex<tag::little_bin_double, fusion::vector1<A0> >, Modifiers> : make_binary_lit_parser<A0, detail::floating_point<64>, boost::endian::endianness::little, 64> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename T>
+    struct as
+      : stateful_tag_type<T, tag::as>
+    {
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::as_string>
+      : mpl::true_ {};
+    template <>
+    struct use_directive<qi::domain, tag::as_wstring>
+      : mpl::true_ {};
+    template <typename T>
+    struct use_directive<qi::domain, tag::stateful_tag<T, tag::as> >
+      : mpl::true_
+    {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::as_string;
+    using spirit::as_wstring;
+    using spirit::as_string_type;
+    using spirit::as_wstring_type;
+    template <typename Subject, typename T>
+    struct as_directive : unary_parser<as_directive<Subject, T> >
+    {
+        typedef Subject subject_type;
+        as_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            Iterator i = first;
+            T as_attr;
+            if (subject.parse(i, last, context, skipper, as_attr))
+            {
+                spirit::traits::assign_to(as_attr, attr);
+                first = i;
+                return true;
+            }
+            return false;
+        }
+        template <typename Iterator, typename Context, typename Skipper>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, T& attr) const
+        {
+            Iterator i = first;
+            if (subject.parse(i, last, context, skipper, attr))
+            {
+                first = i;
+                return true;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("as", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::as_string, Subject, Modifiers>
+    {
+        typedef as_directive<Subject, std::string> result_type;
+        result_type operator()(unused_type, Subject const& subject
+          , unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::as_wstring, Subject, Modifiers>
+    {
+        typedef as_directive<Subject, std::basic_string<wchar_t> > result_type;
+        result_type operator()(unused_type, Subject const& subject
+          , unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+    template <typename T, typename Subject, typename Modifiers>
+    struct make_directive<tag::stateful_tag<T, tag::as>, Subject, Modifiers>
+    {
+        typedef as_directive<Subject, T> result_type;
+        result_type operator()(unused_type, Subject const& subject
+          , unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename T>
+    struct has_semantic_action<qi::as_directive<Subject, T> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename T, typename Attribute
+        , typename Context, typename Iterator>
+    struct handles_container<qi::as_directive<Subject, T>, Attribute
+        , Context, Iterator>
+      : mpl::false_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <typename CharEncoding>
+    struct use_directive<
+        qi::domain, tag::char_code<tag::encoding, CharEncoding> >
+      : mpl::true_ {};
+    template <typename CharEncoding>
+    struct is_modifier_directive<qi::domain, tag::char_code<tag::encoding, CharEncoding> >
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::hold>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::hold;
+    using spirit::hold_type;
+    template <typename Subject>
+    struct hold_directive : unary_parser<hold_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        hold_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<subject_type, Context, Iterator>::type
+            type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            Attribute copy(attr);
+            if (subject.parse(first, last, context, skipper, copy))
+            {
+                traits::swap_impl(copy, attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("hold", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::hold, Subject, Modifiers>
+    {
+        typedef hold_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::hold_directive<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::hold_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::lexeme>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::lexeme;
+    using spirit::lexeme_type;
+    template <typename Subject>
+    struct lexeme_directive : unary_parser<lexeme_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        lexeme_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<subject_type, Context, Iterator>::type
+            type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            return subject.parse(first, last, context
+              , detail::unused_skipper<Skipper>(skipper), attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("lexeme", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::lexeme, Subject, Modifiers>
+    {
+        typedef lexeme_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::lexeme_directive<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::lexeme_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::no_skip>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::no_skip;
+    using spirit::no_skip_type;
+    template <typename Subject>
+    struct no_skip_directive : unary_parser<no_skip_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        no_skip_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<subject_type, Context, Iterator>::type
+            type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return subject.parse(first, last, context
+              , detail::unused_skipper<Skipper>(skipper), attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("no_skip", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::no_skip, Subject, Modifiers>
+    {
+        typedef no_skip_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::no_skip_directive<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::no_skip_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::matches>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::matches;
+    using spirit::matches_type;
+    template <typename Subject>
+    struct matches_directive : unary_parser<matches_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        matches_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef bool type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            bool result = subject.parse(first, last, context, skipper, unused);
+            spirit::traits::assign_to(result, attr);
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("matches", subject.what(context));
+        }
+        Subject subject;
+    private:
+        matches_directive& operator= (matches_directive const&);
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::matches, Subject, Modifiers>
+    {
+        typedef matches_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::matches_directive<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::matches_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <typename CharEncoding>
+    struct use_directive<
+        qi::domain, tag::char_code<tag::no_case, CharEncoding> >
+      : mpl::true_ {};
+    template <typename CharEncoding>
+    struct is_modifier_directive<qi::domain, tag::char_code<tag::no_case, CharEncoding> >
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::omit>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::omit;
+    using spirit::omit_type;
+    template <typename Subject>
+    struct omit_directive : unary_parser<omit_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        omit_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            return subject.parse(first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("omit", subject.what(context));
+        }
+        Subject subject;
+    private:
+        omit_directive& operator= (omit_directive const&);
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::omit, Subject, Modifiers>
+    {
+        typedef omit_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::omit_directive<Subject> >
+      : mpl::false_ {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::omit_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::raw>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::raw;
+    using spirit::raw_type;
+    template <typename Subject>
+    struct raw_directive : unary_parser<raw_directive<Subject> >
+    {
+        typedef Subject subject_type;
+        raw_directive(Subject const& subject)
+          : subject(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef iterator_range<Iterator> type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            Iterator i = first;
+            if (subject.parse(i, last, context, skipper, unused))
+            {
+                spirit::traits::assign_to(first, i, attr);
+                first = i;
+                return true;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("raw", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::raw, Subject, Modifiers>
+    {
+        typedef raw_directive<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::raw_directive<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::raw_directive<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Iterator, typename Context, typename Skipper>
+    struct fail_function
+    {
+        typedef Iterator iterator_type;
+        typedef Context context_type;
+        fail_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+          : first(first)
+          , last(last)
+          , context(context)
+          , skipper(skipper)
+        {
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, Attribute& attr) const
+        {
+            return !component.parse(first, last, context, skipper, attr);
+        }
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            return !component.parse(first, last, context, skipper, unused);
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+    private:
+        fail_function& operator= (fail_function const&);
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Sequence, typename Attribute, typename ValueType>
+    struct negate_weak_substitute_if_not
+      : mpl::if_<
+            Sequence
+          , typename traits::is_weak_substitute<Attribute, ValueType>::type
+          , typename mpl::not_<
+                traits::is_weak_substitute<Attribute, ValueType>
+            >::type>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence, typename Enable = void>
+    struct pass_through_container_base
+      : negate_weak_substitute_if_not<Sequence, Attribute, ValueType>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence = mpl::true_>
+    struct not_compatible_element
+      : mpl::and_<
+            negate_weak_substitute_if_not<Sequence, Attribute, Container>
+          , negate_weak_substitute_if_not<Sequence, Attribute, ValueType> >
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence
+      , bool IsSequence = fusion::traits::is_sequence<ValueType>::value>
+    struct pass_through_container_fusion_sequence
+    {
+        typedef typename mpl::find_if<
+            Attribute, not_compatible_element<Container, ValueType, mpl::_1>
+        >::type iter;
+        typedef typename mpl::end<Attribute>::type end;
+        typedef typename is_same<iter, end>::type type;
+    };
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container_fusion_sequence<
+            Container, ValueType, Attribute, Sequence, true>
+    {
+        typedef typename mpl::find_if<
+            Attribute
+          , not_compatible_element<Container, ValueType, mpl::_1, Sequence>
+        >::type iter;
+        typedef typename mpl::end<Attribute>::type end;
+        typedef typename is_same<iter, end>::type type;
+    };
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container_base<Container, ValueType, Attribute
+          , Sequence
+          , typename enable_if<fusion::traits::is_sequence<Attribute> >::type>
+      : pass_through_container_fusion_sequence<
+            Container, ValueType, Attribute, Sequence>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence, typename AttributeValueType
+      , bool IsSequence = fusion::traits::is_sequence<AttributeValueType>::value>
+    struct pass_through_container_container
+      : mpl::or_<
+            traits::is_weak_substitute<Attribute, Container>
+          , traits::is_weak_substitute<AttributeValueType, Container> >
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence, typename AttributeValueType>
+    struct pass_through_container_container<
+            Container, ValueType, Attribute, Sequence, AttributeValueType, true>
+      : pass_through_container_fusion_sequence<
+            Container, ValueType, AttributeValueType, Sequence>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container_base<
+            Container, ValueType, Attribute, Sequence
+          , typename enable_if<traits::is_container<Attribute> >::type>
+      : detail::pass_through_container_container<
+            Container, ValueType, Attribute, Sequence
+          , typename traits::container_value<Attribute>::type>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence
+      , bool IsSequence = fusion::traits::is_sequence<Attribute>::value>
+    struct pass_through_container_optional
+      : mpl::or_<
+            traits::is_weak_substitute<Attribute, Container>
+          , traits::is_weak_substitute<Attribute, ValueType> >
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container_optional<
+                Container, ValueType, Attribute, Sequence, true>
+      : pass_through_container_fusion_sequence<
+            Container, ValueType, Attribute, Sequence>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container
+      : pass_through_container_base<Container, ValueType, Attribute, Sequence>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container<
+                Container, ValueType, boost::optional<Attribute>, Sequence>
+      : pass_through_container_optional<
+            Container, ValueType, Attribute, Sequence>
+    {};
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container<
+            Container, boost::optional<ValueType>, boost::optional<Attribute>
+          , Sequence>
+      : mpl::not_<traits::is_weak_substitute<Attribute, ValueType> >
+    {};
+    template <typename Container, typename ValueType, typename Sequence>
+    struct pass_through_container<Container, ValueType
+          , boost::detail::variant::void_, Sequence>
+      : mpl::false_
+    {};
+    template <typename Container, typename ValueType, typename Sequence
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    struct pass_through_container<Container, ValueType
+          , boost::variant< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>, Sequence>
+      : mpl::bool_<
+ pass_through_container<Container, ValueType, T0, Sequence>::type::value || pass_through_container<Container, ValueType, T1, Sequence>::type::value || pass_through_container<Container, ValueType, T2, Sequence>::type::value || pass_through_container<Container, ValueType, T3, Sequence>::type::value || pass_through_container<Container, ValueType, T4, Sequence>::type::value || pass_through_container<Container, ValueType, T5, Sequence>::type::value || pass_through_container<Container, ValueType, T6, Sequence>::type::value || pass_through_container<Container, ValueType, T7, Sequence>::type::value || pass_through_container<Container, ValueType, T8, Sequence>::type::value || pass_through_container<Container, ValueType, T9, Sequence>::type::value || pass_through_container<Container, ValueType, T10, Sequence>::type::value || pass_through_container<Container, ValueType, T11, Sequence>::type::value || pass_through_container<Container, ValueType, T12, Sequence>::type::value || pass_through_container<Container, ValueType, T13, Sequence>::type::value || pass_through_container<Container, ValueType, T14, Sequence>::type::value || pass_through_container<Container, ValueType, T15, Sequence>::type::value || pass_through_container<Container, ValueType, T16, Sequence>::type::value || pass_through_container<Container, ValueType, T17, Sequence>::type::value || pass_through_container<Container, ValueType, T18, Sequence>::type::value || pass_through_container<Container, ValueType, T19, Sequence>::type::value || false>
+    {};
+}}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Container, typename ValueType, typename Attribute
+      , typename Sequence>
+    struct pass_through_container<
+            Container, ValueType, Attribute, Sequence, qi::domain>
+      : qi::detail::pass_through_container<
+            Container, ValueType, Attribute, Sequence>
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename F, typename Attr, typename Sequence>
+    struct pass_container
+    {
+        typedef typename F::context_type context_type;
+        typedef typename F::iterator_type iterator_type;
+        pass_container(F const& f, Attr& attr)
+          : f(f), attr(attr) {}
+        template <typename Component>
+        bool dispatch_container(Component const& component, mpl::false_) const
+        {
+            typename traits::container_value<Attr>::type val =
+                typename traits::container_value<Attr>::type();
+            iterator_type save = f.first;
+            bool r = f(component, val);
+            if (!r)
+            {
+                r = !traits::push_back(attr, val);
+                if (r)
+                    f.first = save;
+            }
+            return r;
+        }
+        template <typename Component>
+        bool dispatch_container(Component const& component, mpl::true_) const
+        {
+            return f(component, attr);
+        }
+        template <typename Component>
+        bool dispatch_attribute(Component const& component, mpl::false_) const
+        {
+            return f(component, unused);
+        }
+        template <typename Component>
+        bool dispatch_attribute(Component const& component, mpl::true_) const
+        {
+            typedef typename traits::container_value<Attr>::type value_type;
+            typedef typename traits::attribute_of<
+                Component, context_type, iterator_type>::type
+            rhs_attribute;
+            typedef mpl::and_<
+                traits::handles_container<
+                    Component, Attr, context_type, iterator_type>
+              , traits::pass_through_container<
+                    Attr, value_type, rhs_attribute, Sequence, qi::domain>
+            > predicate;
+            return dispatch_container(component, predicate());
+        }
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            typedef typename traits::not_is_unused<
+                typename traits::attribute_of<
+                    Component, context_type, iterator_type
+                >::type
+            >::type predicate;
+            traits::make_container(attr);
+            return dispatch_attribute(component, predicate());
+        }
+        F f;
+        Attr& attr;
+    private:
+        pass_container& operator= (pass_container const&);
+    };
+    template <typename F, typename Attr>
+    inline pass_container<F, Attr, mpl::false_>
+    make_pass_container(F const& f, Attr& attr)
+    {
+        return pass_container<F, Attr, mpl::false_>(f, attr);
+    }
+    template <typename F, typename Attr>
+    inline pass_container<F, Attr, mpl::true_>
+    make_sequence_pass_container(F const& f, Attr& attr)
+    {
+        return pass_container<F, Attr, mpl::true_>(f, attr);
+    }
+}}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::dereference>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct kleene : unary_parser<kleene<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::build_std_vector<
+                    typename traits::
+                        attribute_of<Subject, Context, Iterator>::type
+                >::type
+            type;
+        };
+        kleene(Subject const& subject)
+          : subject(subject) {}
+        template <typename F>
+        bool parse_container(F f) const
+        {
+            while (!f (subject))
+                ;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            traits::make_container(attr);
+            typedef detail::fail_function<Iterator, Context, Skipper>
+                fail_function;
+            Iterator iter = first;
+            fail_function f(iter, last, context, skipper);
+            parse_container(detail::make_pass_container(f, attr));
+            first = f.first;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("kleene", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::dereference, Elements, Modifiers>
+      : make_unary_composite<Elements, kleene>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::kleene<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::kleene<Subject>, Attribute
+          , Context, Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::repeat>
+      : mpl::true_ {};
+    template <typename T>
+    struct use_directive<qi::domain
+      , terminal_ex<tag::repeat
+        , fusion::vector1<T> >
+    > : mpl::true_ {};
+    template <typename T>
+    struct use_directive<qi::domain
+      , terminal_ex<tag::repeat
+        , fusion::vector2<T, T> >
+    > : mpl::true_ {};
+    template <typename T>
+    struct use_directive<qi::domain
+      , terminal_ex<tag::repeat
+        , fusion::vector2<T, inf_type> >
+    > : mpl::true_ {};
+    template <>
+    struct use_lazy_directive<
+        qi::domain
+      , tag::repeat
+      , 1
+    > : mpl::true_ {};
+    template <>
+    struct use_lazy_directive<
+        qi::domain
+      , tag::repeat
+      , 2
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::repeat;
+    using spirit::inf;
+    using spirit::repeat_type;
+    using spirit::inf_type;
+    template <typename T>
+    struct exact_iterator
+    {
+        exact_iterator(T const exact)
+          : exact(exact) {}
+        typedef T type;
+        T start() const { return 0; }
+        bool got_max(T i) const { return i >= exact; }
+        bool got_min(T i) const { return i >= exact; }
+        T const exact;
+    private:
+        exact_iterator& operator= (exact_iterator const&);
+    };
+    template <typename T>
+    struct finite_iterator
+    {
+        finite_iterator(T const min, T const max)
+          : min (min)
+          , max (max) {}
+        typedef T type;
+        T start() const { return 0; }
+        bool got_max(T i) const { return i >= max; }
+        bool got_min(T i) const { return i >= min; }
+        T const min;
+        T const max;
+    private:
+        finite_iterator& operator= (finite_iterator const&);
+    };
+    template <typename T>
+    struct infinite_iterator
+    {
+        infinite_iterator(T const min)
+          : min (min) {}
+        typedef T type;
+        T start() const { return 0; }
+        bool got_max(T ) const { return false; }
+        bool got_min(T i) const { return i >= min; }
+        T const min;
+    private:
+        infinite_iterator& operator= (infinite_iterator const&);
+    };
+    template <typename Subject, typename LoopIter>
+    struct repeat_parser : unary_parser<repeat_parser<Subject, LoopIter> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::build_std_vector<
+                    typename traits::attribute_of<
+                        Subject, Context, Iterator>::type
+                >::type
+            type;
+        };
+        repeat_parser(Subject const& subject, LoopIter const& iter)
+          : subject(subject), iter(iter) {}
+        template <typename F>
+        bool parse_container(F f) const
+        {
+            typename LoopIter::type i = iter.start();
+            for ( ; !iter.got_min(i); ++i)
+            {
+                if (f (subject))
+                    return false;
+            }
+            typename F::iterator_type save = f.f.first;
+            for ( ; !iter.got_max(i); ++i)
+            {
+                if (f (subject))
+                    break;
+                save = f.f.first;
+            }
+            f.f.first = save;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::fail_function<Iterator, Context, Skipper>
+                fail_function;
+            traits::make_container(attr);
+            Iterator iter = first;
+            fail_function f(iter, last, context, skipper);
+            if (!parse_container(detail::make_pass_container(f, attr)))
+                return false;
+            first = f.first;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("repeat", subject.what(context));
+        }
+        Subject subject;
+        LoopIter iter;
+    private:
+        repeat_parser& operator= (repeat_parser const&);
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::repeat, Subject, Modifiers>
+    {
+        typedef kleene<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+    template <typename T, typename Subject, typename Modifiers>
+    struct make_directive<
+        terminal_ex<tag::repeat, fusion::vector1<T> >, Subject, Modifiers>
+    {
+        typedef exact_iterator<T> iterator_type;
+        typedef repeat_parser<Subject, iterator_type> result_type;
+        template <typename Terminal>
+        result_type operator()(
+            Terminal const& term, Subject const& subject, unused_type) const
+        {
+            return result_type(subject, fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename T, typename Subject, typename Modifiers>
+    struct make_directive<
+        terminal_ex<tag::repeat, fusion::vector2<T, T> >, Subject, Modifiers>
+    {
+        typedef finite_iterator<T> iterator_type;
+        typedef repeat_parser<Subject, iterator_type> result_type;
+        template <typename Terminal>
+        result_type operator()(
+            Terminal const& term, Subject const& subject, unused_type) const
+        {
+            return result_type(subject,
+                iterator_type(
+                    fusion::at_c<0>(term.args)
+                  , fusion::at_c<1>(term.args)
+                )
+            );
+        }
+    };
+    template <typename T, typename Subject, typename Modifiers>
+    struct make_directive<
+        terminal_ex<tag::repeat
+        , fusion::vector2<T, inf_type> >, Subject, Modifiers>
+    {
+        typedef infinite_iterator<T> iterator_type;
+        typedef repeat_parser<Subject, iterator_type> result_type;
+        template <typename Terminal>
+        result_type operator()(
+            Terminal const& term, Subject const& subject, unused_type) const
+        {
+            return result_type(subject, fusion::at_c<0>(term.args));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename LoopIter>
+    struct has_semantic_action<qi::repeat_parser<Subject, LoopIter> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename LoopIter, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::repeat_parser<Subject, LoopIter>
+          , Attribute, Context, Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_directive<qi::domain, tag::skip>
+      : mpl::true_ {};
+    template <typename T>
+    struct use_directive<qi::domain
+      , terminal_ex<tag::skip
+        , fusion::vector1<T> >
+    > : boost::spirit::traits::matches<qi::domain, T> {};
+    template <>
+    struct use_lazy_directive<
+        qi::domain
+      , tag::skip
+      , 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::skip;
+    using spirit::skip_type;
+    template <typename Subject>
+    struct reskip_parser : unary_parser<reskip_parser<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<Subject, Context, Iterator>::type
+            type;
+        };
+        reskip_parser(Subject const& subject)
+          : subject(subject) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& u
+          , Attribute& attr) const
+        {
+            return subject.parse(first, last, context
+              , detail::get_skipper(u), attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("skip", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Subject, typename Skipper>
+    struct skip_parser : unary_parser<skip_parser<Subject, Skipper> >
+    {
+        typedef Subject subject_type;
+        typedef Skipper skipper_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<Subject, Context, Iterator>::type
+            type;
+        };
+        skip_parser(Subject const& subject, Skipper const& skipper)
+          : subject(subject), skipper(skipper) {}
+        template <typename Iterator, typename Context
+          , typename Skipper_, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper_ const&
+          , Attribute& attr) const
+        {
+            return subject.parse(first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("skip", subject.what(context));
+        }
+        Subject subject;
+        Skipper skipper;
+    };
+    template <typename Subject, typename Modifiers>
+    struct make_directive<tag::skip, Subject, Modifiers>
+    {
+        typedef reskip_parser<Subject> result_type;
+        result_type operator()(unused_type, Subject const& subject, unused_type) const
+        {
+            return result_type(subject);
+        }
+    };
+    template <typename Skipper, typename Subject, typename Modifiers>
+    struct make_directive<
+        terminal_ex<tag::skip, fusion::vector1<Skipper> >, Subject, Modifiers>
+    {
+        typedef typename
+            result_of::compile<qi::domain, Skipper, Modifiers>::type
+        skipper_type;
+        typedef skip_parser<Subject, skipper_type> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, Subject const& subject
+          , Modifiers const& modifiers) const
+        {
+            return result_type(subject
+              , compile<qi::domain>(fusion::at_c<0>(term.args), modifiers));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::reskip_parser<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Skipper>
+    struct has_semantic_action<qi::skip_parser<Subject, Skipper> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::reskip_parser<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+    template <typename Subject, typename Skipper, typename Attribute
+        , typename Context, typename Iterator>
+    struct handles_container<qi::skip_parser<Subject, Skipper>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost
+{
+     typedef boost::uintmax_t static_min_max_unsigned_type;
+     typedef boost::intmax_t static_min_max_signed_type;
+     typedef boost::uintmax_t static_log2_argument_type;
+     typedef int static_log2_result_type;
+template < class T >
+    class integer_traits;
+template < >
+    class integer_traits< bool >;
+template < >
+    class integer_traits< char >;
+template < >
+    class integer_traits< signed char >;
+template < >
+    class integer_traits< unsigned char >;
+template < >
+    class integer_traits< wchar_t >;
+template < >
+    class integer_traits< short >;
+template < >
+    class integer_traits< unsigned short >;
+template < >
+    class integer_traits< int >;
+template < >
+    class integer_traits< unsigned int >;
+template < >
+    class integer_traits< long >;
+template < >
+    class integer_traits< unsigned long >;
+template < >
+class integer_traits< ::boost::long_long_type>;
+template < >
+class integer_traits< ::boost::ulong_long_type >;
+template < typename LeastInt >
+    struct int_fast_t;
+template< int Bits >
+    struct int_t;
+template< int Bits >
+    struct uint_t;
+    template< boost::long_long_type MaxValue >
+    struct int_max_value_t;
+  template< boost::long_long_type MinValue >
+    struct int_min_value_t;
+  template< boost::ulong_long_type MaxValue >
+    struct uint_value_t;
+template < std::size_t Bit >
+    struct high_bit_mask_t;
+template < std::size_t Bits >
+    struct low_bits_mask_t;
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
+template <static_log2_argument_type Value >
+    struct static_log2;
+template <> struct static_log2<0u>;
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_min;
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_max;
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_min;
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_max;
+}
+namespace boost
+{
+  template< typename LeastInt >
+  struct int_fast_t
+  {
+     typedef LeastInt fast;
+     typedef fast type;
+  };
+  namespace detail{
+  template< int Category > struct int_least_helper {};
+  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
+  template<> struct int_least_helper<2> { typedef long least; };
+  template<> struct int_least_helper<3> { typedef int least; };
+  template<> struct int_least_helper<4> { typedef short least; };
+  template<> struct int_least_helper<5> { typedef signed char least; };
+  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
+  template<> struct int_least_helper<7> { typedef unsigned long least; };
+  template<> struct int_least_helper<8> { typedef unsigned int least; };
+  template<> struct int_least_helper<9> { typedef unsigned short least; };
+  template<> struct int_least_helper<10> { typedef unsigned char least; };
+  template <int Bits>
+  struct exact_signed_base_helper{};
+  template <int Bits>
+  struct exact_unsigned_base_helper{};
+  template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };
+  template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };
+  template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };
+  template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
+  }
+  template< int Bits >
+  struct int_t : public detail::exact_signed_base_helper<Bits>
+  {
+      typedef typename detail::int_least_helper
+        <
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +
+          (Bits-1 <= ::std::numeric_limits<long>::digits) +
+          (Bits-1 <= ::std::numeric_limits<int>::digits) +
+          (Bits-1 <= ::std::numeric_limits<short>::digits) +
+          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+  template< int Bits >
+  struct uint_t : public detail::exact_unsigned_base_helper<Bits>
+  {
+      typedef typename detail::int_least_helper
+        <
+          5 +
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +
+          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned char>::digits)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+  template< boost::long_long_type MaxValue >
+  struct int_max_value_t
+  {
+      typedef typename detail::int_least_helper
+        <
+          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
+          (MaxValue <= ::boost::integer_traits<long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+  template< boost::long_long_type MinValue >
+  struct int_min_value_t
+  {
+      typedef typename detail::int_least_helper
+        <
+          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
+          (MinValue >= ::boost::integer_traits<long>::const_min) +
+          (MinValue >= ::boost::integer_traits<int>::const_min) +
+          (MinValue >= ::boost::integer_traits<short>::const_min) +
+          (MinValue >= ::boost::integer_traits<signed char>::const_min)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+  template< boost::ulong_long_type MaxValue >
+  struct uint_value_t
+  {
+      typedef typename detail::int_least_helper
+        <
+          5 +
+          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+}
+namespace boost {
+namespace detail {
+template <typename T> struct is_union_impl
+{
+   static const bool value = __is_union(T);
+};
+}
+template< typename T > struct is_union : public ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { public: };
+}
+namespace boost {
+template<typename F, typename G>
+  bool function_equal_impl(const F& f, const G& g, long)
+  { return f == g; }
+template<typename F, typename G>
+  bool function_equal(const F& f, const G& g)
+  { return function_equal_impl(f, g, 0); }
+}
+namespace boost {
+  class bad_function_call;
+  template<typename Signature> class function;
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4>
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5>
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6>
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7>
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8>
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9>
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10>
+    class function10;
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      class X;
+      union function_buffer
+      {
+        mutable void* obj_ptr;
+        struct type_t {
+          const detail::sp_typeinfo* type;
+          bool const_qualified;
+          bool volatile_qualified;
+        } type;
+        mutable void (*func_ptr)();
+        struct bound_memfunc_ptr_t {
+          void (X::*memfunc_ptr)(int);
+          void* obj_ptr;
+        } bound_memfunc_ptr;
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+        mutable char data;
+      };
+      struct unusable
+      {
+        unusable() {}
+        template<typename T> unusable(const T&) {}
+      };
+      template<typename T> struct function_return_type { typedef T type; };
+      template<>
+      struct function_return_type<void>
+      {
+        typedef unusable type;
+      };
+      enum functor_manager_operation_type {
+        clone_functor_tag,
+        move_functor_tag,
+        destroy_functor_tag,
+        check_functor_type_tag,
+        get_functor_type_tag
+      };
+      struct function_ptr_tag {};
+      struct function_obj_tag {};
+      struct member_ptr_tag {};
+      struct function_obj_ref_tag {};
+      template<typename F>
+      class get_function_tag
+      {
+        typedef typename mpl::if_c<(is_pointer<F>::value),
+                                   function_ptr_tag,
+                                   function_obj_tag>::type ptr_or_obj_tag;
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+                                   member_ptr_tag,
+                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+                                   function_obj_ref_tag,
+                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
+      public:
+        typedef or_ref_tag type;
+      };
+      template<typename F>
+      struct reference_manager
+      {
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag:
+            out_buffer.obj_ref = in_buffer.obj_ref;
+            return;
+          case move_functor_tag:
+            out_buffer.obj_ref = in_buffer.obj_ref;
+            in_buffer.obj_ref.obj_ptr = 0;
+            return;
+          case destroy_functor_tag:
+            out_buffer.obj_ref.obj_ptr = 0;
+            return;
+          case check_functor_type_tag:
+            {
+              const detail::sp_typeinfo& check_type
+                = *out_buffer.type.type;
+              if ((std::strcmp((check_type).name(),(typeid(F)).name()) == 0)
+                  && (!in_buffer.obj_ref.is_const_qualified
+                      || out_buffer.type.const_qualified)
+                  && (!in_buffer.obj_ref.is_volatile_qualified
+                      || out_buffer.type.volatile_qualified))
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
+              else
+                out_buffer.obj_ptr = 0;
+            }
+            return;
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(F);
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
+            return;
+          }
+        }
+      };
+      template<typename F>
+      struct function_allows_small_object_optimization
+      {
+        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))
+                                                       ;
+      };
+      template <typename F,typename A>
+      struct functor_wrapper: public F, public A
+      {
+        functor_wrapper( F f, A a ):
+          F(f),
+          A(a)
+        {
+        }
+        functor_wrapper(const functor_wrapper& f) :
+          F(static_cast<const F&>(f)),
+          A(static_cast<const A&>(f))
+        {
+        }
+      };
+      template<typename Functor>
+      struct functor_manager_common
+      {
+        typedef Functor functor_type;
+        static inline void
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag)
+            out_buffer.func_ptr = in_buffer.func_ptr;
+          else if (op == move_functor_tag) {
+            out_buffer.func_ptr = in_buffer.func_ptr;
+            in_buffer.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
+            out_buffer.func_ptr = 0;
+          else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+        static inline void
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag || op == move_functor_tag) {
+            const functor_type* in_functor =
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
+            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
+            if (op == move_functor_tag) {
+              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
+              (void)f;
+              f->~Functor();
+            }
+          } else if (op == destroy_functor_tag) {
+             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
+             (void)f;
+             f->~Functor();
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = &in_buffer.data;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+      };
+      template<typename Functor>
+      struct functor_manager
+      {
+      private:
+        typedef Functor functor_type;
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::false_)
+        {
+          if (op == clone_functor_tag) {
+            const functor_type* f =
+              static_cast<const functor_type*>(in_buffer.obj_ptr);
+            functor_type* new_f = new functor_type(*f);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+            functor_type* f =
+              static_cast<functor_type*>(out_buffer.obj_ptr);
+            delete f;
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, member_ptr_tag)
+        {
+          manager(in_buffer, out_buffer, op, mpl::true_());
+        }
+      public:
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+      template<typename Functor, typename Allocator>
+      struct functor_manager_a
+      {
+      private:
+        typedef Functor functor_type;
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::false_)
+        {
+          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          if (op == clone_functor_tag) {
+            const functor_wrapper_type* f =
+              static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
+            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+            wrapper_allocator.construct(copy, *f);
+            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+            functor_wrapper_type* victim =
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
+            wrapper_allocator.destroy(victim);
+            wrapper_allocator.deallocate(victim,1);
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+      public:
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+      struct useless_clear_type {};
+      struct vtable_base
+      {
+        void (*manager)(const function_buffer& in_buffer,
+                        function_buffer& out_buffer,
+                        functor_manager_operation_type op);
+      };
+    }
+  }
+class function_base
+{
+public:
+  function_base() : vtable(0) { }
+  bool empty() const { return !vtable; }
+  const detail::sp_typeinfo& target_type() const
+  {
+    if (!vtable) return typeid(void);
+    detail::function::function_buffer type;
+    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.type.type;
+  }
+  template<typename Functor>
+    Functor* target()
+    {
+      if (!vtable) return 0;
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = is_const<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+      return static_cast<Functor*>(type_result.obj_ptr);
+    }
+  template<typename Functor>
+    const Functor* target() const
+    {
+      if (!vtable) return 0;
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = true;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+      return static_cast<const Functor*>(type_result.obj_ptr);
+    }
+  template<typename F>
+    bool contains(const F& f) const
+    {
+      if (const F* fp = this->template target<F>())
+      {
+        return function_equal(*fp, f);
+      } else {
+        return false;
+      }
+    }
+public:
+  detail::function::vtable_base* get_vtable() const {
+    return reinterpret_cast<detail::function::vtable_base*>(
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+  }
+  bool has_trivial_copy_and_destroy() const {
+    return reinterpret_cast<std::size_t>(vtable) & 0x01;
+  }
+  detail::function::vtable_base* vtable;
+  mutable detail::function::function_buffer functor;
+};
+class bad_function_call : public std::runtime_error
+{
+public:
+  bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+inline bool operator==(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return f.empty();
+}
+inline bool operator!=(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return !f.empty();
+}
+inline bool operator==(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return f.empty();
+}
+inline bool operator!=(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return !f.empty();
+}
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+namespace detail {
+  namespace function {
+    inline bool has_empty_target(const function_base* f)
+    {
+      return f->empty();
+    }
+    inline bool has_empty_target(...)
+    {
+      return false;
+    }
+  }
+}
+}
+namespace boost
+{
+namespace _mfi
+{
+template<class R, class T > class mf0
+{
+public:
+    typedef R result_type;
+    typedef T * argument_type;
+private:
+    typedef R ( T::*F) ();
+    F f_;
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+public:
+    explicit mf0(F f): f_(f) {}
+    R operator()(T * p) const
+    {
+        return (p->*f_)();
+    }
+    template<class U> R operator()(U & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+    R operator()(T & t) const
+    {
+        return (t.*f_)();
+    }
+    bool operator==(mf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T > class cmf0
+{
+public:
+    typedef R result_type;
+    typedef T const * argument_type;
+private:
+    typedef R ( T::*F) () const;
+    F f_;
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+public:
+    explicit cmf0(F f): f_(f) {}
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+    R operator()(T const & t) const
+    {
+        return (t.*f_)();
+    }
+    bool operator==(cmf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1 > class mf1
+{
+public:
+    typedef R result_type;
+    typedef T * first_argument_type;
+    typedef A1 second_argument_type;
+private:
+    typedef R ( T::*F) (A1);
+    F f_;
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+public:
+    explicit mf1(F f): f_(f) {}
+    R operator()(T * p, A1 a1) const
+    {
+        return (p->*f_)(a1);
+    }
+    template<class U> R operator()(U & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+    R operator()(T & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+    bool operator==(mf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1 > class cmf1
+{
+public:
+    typedef R result_type;
+    typedef T const * first_argument_type;
+    typedef A1 second_argument_type;
+private:
+    typedef R ( T::*F) (A1) const;
+    F f_;
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+public:
+    explicit cmf1(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+    R operator()(T const & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+    bool operator==(cmf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2 > class mf2
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2);
+    F f_;
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+public:
+    explicit mf2(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2) const
+    {
+        return (p->*f_)(a1, a2);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+    R operator()(T & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+    bool operator==(mf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2 > class cmf2
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2) const;
+    F f_;
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+public:
+    explicit cmf2(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+    R operator()(T const & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+    bool operator==(cmf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3 > class mf3
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3);
+    F f_;
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+public:
+    explicit mf3(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
+    {
+        return (p->*f_)(a1, a2, a3);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+    bool operator==(mf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3 > class cmf3
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3) const;
+    F f_;
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+public:
+    explicit cmf3(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+    bool operator==(cmf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4);
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+public:
+    explicit mf4(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (p->*f_)(a1, a2, a3, a4);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+    bool operator==(mf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4) const;
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+public:
+    explicit cmf4(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+    bool operator==(cmf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5);
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+public:
+    explicit mf5(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+    bool operator==(mf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+public:
+    explicit cmf5(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+    bool operator==(cmf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+public:
+    explicit mf6(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+    bool operator==(mf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+public:
+    explicit cmf6(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+    bool operator==(cmf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+public:
+    explicit mf7(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+    bool operator==(mf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+public:
+    explicit cmf7(F f): f_(f) {}
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+    bool operator==(cmf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+public:
+    explicit mf8(F f): f_(f) {}
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    bool operator==(mf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(mf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
+{
+public:
+    typedef R result_type;
+private:
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    F f_;
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+public:
+    explicit cmf8(F f): f_(f) {}
+    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+    bool operator==(cmf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(cmf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+}
+template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
+{
+    return _mfi::mf0<R, T>(f);
+}
+template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
+{
+    return _mfi::cmf0<R, T>(f);
+}
+template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
+{
+    return _mfi::mf1<R, T, A1>(f);
+}
+template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
+{
+    return _mfi::cmf1<R, T, A1>(f);
+}
+template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
+{
+    return _mfi::mf2<R, T, A1, A2>(f);
+}
+template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
+{
+    return _mfi::cmf2<R, T, A1, A2>(f);
+}
+template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
+{
+    return _mfi::mf3<R, T, A1, A2, A3>(f);
+}
+template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
+{
+    return _mfi::cmf3<R, T, A1, A2, A3>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
+{
+    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
+{
+    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
+{
+    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
+{
+    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
+{
+    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
+{
+    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
+{
+    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+{
+    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+{
+    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+{
+    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+namespace _mfi
+{
+template<class R, class T> class dm
+{
+public:
+    typedef R const & result_type;
+    typedef T const * argument_type;
+private:
+    typedef R (T::*F);
+    F f_;
+    template<class U> R const & call(U & u, T const *) const
+    {
+        return (u.*f_);
+    }
+    template<class U> R const & call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_);
+    }
+public:
+    explicit dm(F f): f_(f) {}
+    R & operator()(T * p) const
+    {
+        return (p->*f_);
+    }
+    R const & operator()(T const * p) const
+    {
+        return (p->*f_);
+    }
+    template<class U> R const & operator()(U const & u) const
+    {
+        return call(u, &u);
+    }
+    R & operator()(T & t) const
+    {
+        return (t.*f_);
+    }
+    R const & operator()(T const & t) const
+    {
+        return (t.*f_);
+    }
+    bool operator==(dm const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+    bool operator!=(dm const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+}
+template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
+{
+    return _mfi::dm<R, T>(f);
+}
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R
+        >
+      struct function_invoker0
+      {
+        static R invoke(function_buffer& function_ptr
+                        )
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f();
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R
+        >
+      struct void_function_invoker0
+      {
+        static void
+        invoke(function_buffer& function_ptr
+               )
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f();
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R
+      >
+      struct function_obj_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)();
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R
+      >
+      struct void_function_obj_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)();
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R
+      >
+      struct function_ref_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)();
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R
+      >
+      struct void_function_ref_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)();
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R
+      >
+      struct get_function_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker0<
+                            FunctionPtr,
+                            R
+                          >,
+                          function_invoker0<
+                            FunctionPtr,
+                            R
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R
+       >
+      struct get_function_obj_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker0<
+                            FunctionObj,
+                            R
+                          >,
+                          function_obj_invoker0<
+                            FunctionObj,
+                            R
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R
+       >
+      struct get_function_ref_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker0<
+                            FunctionObj,
+                            R
+                          >,
+                          function_ref_invoker0<
+                            FunctionObj,
+                            R
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker0 { };
+      template<>
+      struct get_invoker0<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker0<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker0<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R >
+      struct basic_vtable0
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            );
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R
+  >
+  class function0 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable0<
+              R >
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 0;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 0;
+    typedef function0 self_type;
+    function0() : function_base() { }
+    template<typename Functor>
+    function0(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function0(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function0(clear_type*) : function_base() { }
+    function0(const function0& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function0() { clear(); }
+    result_type operator()() const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor );
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function0&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function0& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function0& operator=(const function0& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function0& other)
+    {
+      if (&other == this)
+        return;
+      function0 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function0& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R
+                        >
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R
+                         ,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function0& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R >
+  inline void swap(function0<
+                     R
+                   >& f1,
+                   function0<
+                     R
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R >
+  void operator==(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >&);
+template<typename R >
+  void operator!=(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >& );
+template<typename R
+         >
+class function<R (void)>
+  : public function0<R >
+{
+  typedef function0<R > base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+        >
+      struct function_invoker1
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+        >
+      struct void_function_invoker1
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct function_obj_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct void_function_obj_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct function_ref_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+      >
+      struct void_function_ref_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+      >
+      struct function_mem_invoker1
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+      >
+      struct function_void_mem_invoker1
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0
+      >
+      struct get_function_invoker1
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker1<
+                            FunctionPtr,
+                            R ,
+                            T0
+                          >,
+                          function_invoker1<
+                            FunctionPtr,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+       >
+      struct get_function_obj_invoker1
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >,
+                          function_obj_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0
+       >
+      struct get_function_ref_invoker1
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >,
+                          function_ref_invoker1<
+                            FunctionObj,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0
+       >
+      struct get_member_invoker1
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker1<
+                            MemberPtr,
+                            R ,
+                            T0
+                          >,
+                          function_mem_invoker1<
+                            MemberPtr,
+                            R ,
+                            T0
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker1 { };
+      template<>
+      struct get_invoker1<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_invoker1<
+                             FunctionPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker1<
+                             FunctionPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker1<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_member_invoker1<
+                             MemberPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker1<
+                             MemberPtr,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker1<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker1<
+                             FunctionObj,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker1<
+                             FunctionObj,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker1<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker1<
+                             typename RefWrapper::type,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker1<
+                             typename RefWrapper::type,
+                             R ,
+                             T0
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0>
+      struct basic_vtable1
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0
+  >
+  class function1 : public function_base
+    , public std::unary_function<T0,R>
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable1<
+              R , T0>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 1;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    typedef T0 argument_type;
+    static const int arity = 1;
+    typedef T0 arg1_type;
+    typedef function1 self_type;
+    function1() : function_base() { }
+    template<typename Functor>
+    function1(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function1(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function1(clear_type*) : function_base() { }
+    function1(const function1& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function1() { clear(); }
+    result_type operator()( T0 a0) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function1&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function1& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function1& operator=(const function1& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function1& other)
+    {
+      if (&other == this)
+        return;
+      function1 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function1& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker1<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker1<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function1& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0>
+  inline void swap(function1<
+                     R ,
+                     T0
+                   >& f1,
+                   function1<
+                     R ,
+                     T0
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0>
+  void operator==(const function1<
+                          R ,
+                          T0>&,
+                  const function1<
+                          R ,
+                          T0>&);
+template<typename R , typename T0>
+  void operator!=(const function1<
+                          R ,
+                          T0>&,
+                  const function1<
+                          R ,
+                          T0>& );
+template<typename R ,
+         typename T0>
+class function<R ( T0)>
+  : public function1<R , T0>
+{
+  typedef function1<R , T0> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct function_invoker2
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct void_function_invoker2
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_obj_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_obj_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_ref_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_ref_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_mem_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_void_mem_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct get_function_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_obj_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_ref_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_member_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker2 { };
+      template<>
+      struct get_invoker2<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker2<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker2<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker2<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1>
+      struct basic_vtable2
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1
+  >
+  class function2 : public function_base
+    , public std::binary_function<T0,T1,R>
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable2<
+              R , T0 , T1>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 2;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    typedef T0 first_argument_type;
+    typedef T1 second_argument_type;
+    static const int arity = 2;
+    typedef T0 arg1_type; typedef T1 arg2_type;
+    typedef function2 self_type;
+    function2() : function_base() { }
+    template<typename Functor>
+    function2(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function2(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function2(clear_type*) : function_base() { }
+    function2(const function2& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function2() { clear(); }
+    result_type operator()( T0 a0 , T1 a1) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function2&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function2& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function2& operator=(const function2& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function2& other)
+    {
+      if (&other == this)
+        return;
+      function2 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function2& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function2& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1>
+  inline void swap(function2<
+                     R ,
+                     T0 , T1
+                   >& f1,
+                   function2<
+                     R ,
+                     T0 , T1
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1>
+  void operator==(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>&);
+template<typename R , typename T0 , typename T1>
+  void operator!=(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>& );
+template<typename R ,
+         typename T0 , typename T1>
+class function<R ( T0 , T1)>
+  : public function2<R , T0 , T1>
+{
+  typedef function2<R , T0 , T1> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+        >
+      struct function_invoker3
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+        >
+      struct void_function_invoker3
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_obj_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct void_function_obj_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_ref_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct void_function_ref_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_mem_invoker3
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct function_void_mem_invoker3
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+      >
+      struct get_function_invoker3
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker3<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_invoker3<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_function_obj_invoker3
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_obj_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_function_ref_invoker3
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_ref_invoker3<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2
+       >
+      struct get_member_invoker3
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker3<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >,
+                          function_mem_invoker3<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker3 { };
+      template<>
+      struct get_invoker3<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_invoker3<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker3<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker3<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_member_invoker3<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker3<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker3<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker3<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker3<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker3<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker3<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker3<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2>
+      struct basic_vtable3
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2
+  >
+  class function3 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable3<
+              R , T0 , T1 , T2>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 3;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 3;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type;
+    typedef function3 self_type;
+    function3() : function_base() { }
+    template<typename Functor>
+    function3(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function3(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function3(clear_type*) : function_base() { }
+    function3(const function3& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function3() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function3&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function3& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function3& operator=(const function3& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function3& other)
+    {
+      if (&other == this)
+        return;
+      function3 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function3& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker3<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker3<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function3& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2>
+  inline void swap(function3<
+                     R ,
+                     T0 , T1 , T2
+                   >& f1,
+                   function3<
+                     R ,
+                     T0 , T1 , T2
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2>
+  void operator==(const function3<
+                          R ,
+                          T0 , T1 , T2>&,
+                  const function3<
+                          R ,
+                          T0 , T1 , T2>&);
+template<typename R , typename T0 , typename T1 , typename T2>
+  void operator!=(const function3<
+                          R ,
+                          T0 , T1 , T2>&,
+                  const function3<
+                          R ,
+                          T0 , T1 , T2>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2>
+class function<R ( T0 , T1 , T2)>
+  : public function3<R , T0 , T1 , T2>
+{
+  typedef function3<R , T0 , T1 , T2> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+        >
+      struct function_invoker4
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+        >
+      struct void_function_invoker4
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_obj_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct void_function_obj_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_ref_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct void_function_ref_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_mem_invoker4
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct function_void_mem_invoker4
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+      >
+      struct get_function_invoker4
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker4<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_invoker4<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_function_obj_invoker4
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_obj_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_function_ref_invoker4
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_ref_invoker4<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3
+       >
+      struct get_member_invoker4
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker4<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >,
+                          function_mem_invoker4<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker4 { };
+      template<>
+      struct get_invoker4<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_invoker4<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker4<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker4<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_member_invoker4<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker4<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker4<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker4<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker4<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker4<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker4<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker4<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+      struct basic_vtable4
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3
+  >
+  class function4 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable4<
+              R , T0 , T1 , T2 , T3>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 4;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 4;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type;
+    typedef function4 self_type;
+    function4() : function_base() { }
+    template<typename Functor>
+    function4(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function4(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function4(clear_type*) : function_base() { }
+    function4(const function4& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function4() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function4&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function4& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function4& operator=(const function4& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function4& other)
+    {
+      if (&other == this)
+        return;
+      function4 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function4& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker4<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker4<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function4& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  inline void swap(function4<
+                     R ,
+                     T0 , T1 , T2 , T3
+                   >& f1,
+                   function4<
+                     R ,
+                     T0 , T1 , T2 , T3
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  void operator==(const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&,
+                  const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3>
+  void operator!=(const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>&,
+                  const function4<
+                          R ,
+                          T0 , T1 , T2 , T3>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3>
+class function<R ( T0 , T1 , T2 , T3)>
+  : public function4<R , T0 , T1 , T2 , T3>
+{
+  typedef function4<R , T0 , T1 , T2 , T3> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+        >
+      struct function_invoker5
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+        >
+      struct void_function_invoker5
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_obj_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct void_function_obj_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_ref_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct void_function_ref_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_mem_invoker5
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct function_void_mem_invoker5
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+      >
+      struct get_function_invoker5
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker5<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_invoker5<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_function_obj_invoker5
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_obj_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_function_ref_invoker5
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_ref_invoker5<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+       >
+      struct get_member_invoker5
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker5<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >,
+                          function_mem_invoker5<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker5 { };
+      template<>
+      struct get_invoker5<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_invoker5<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker5<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker5<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_member_invoker5<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker5<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker5<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker5<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker5<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker5<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker5<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker5<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+      struct basic_vtable5
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+  >
+  class function5 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable5<
+              R , T0 , T1 , T2 , T3 , T4>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 5;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 5;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type;
+    typedef function5 self_type;
+    function5() : function_base() { }
+    template<typename Functor>
+    function5(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function5(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function5(clear_type*) : function_base() { }
+    function5(const function5& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function5() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function5&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function5& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function5& operator=(const function5& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function5& other)
+    {
+      if (&other == this)
+        return;
+      function5 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function5& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker5<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker5<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function5& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  inline void swap(function5<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4
+                   >& f1,
+                   function5<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  void operator==(const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&,
+                  const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+  void operator!=(const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>&,
+                  const function5<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+class function<R ( T0 , T1 , T2 , T3 , T4)>
+  : public function5<R , T0 , T1 , T2 , T3 , T4>
+{
+  typedef function5<R , T0 , T1 , T2 , T3 , T4> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+        >
+      struct function_invoker6
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+        >
+      struct void_function_invoker6
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_obj_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct void_function_obj_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_ref_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct void_function_ref_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_mem_invoker6
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct function_void_mem_invoker6
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+      >
+      struct get_function_invoker6
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker6<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_invoker6<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_function_obj_invoker6
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_obj_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_function_ref_invoker6
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_ref_invoker6<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+       >
+      struct get_member_invoker6
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker6<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >,
+                          function_mem_invoker6<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker6 { };
+      template<>
+      struct get_invoker6<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_invoker6<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker6<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker6<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_member_invoker6<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker6<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker6<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker6<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker6<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker6<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker6<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker6<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+      struct basic_vtable6
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+  >
+  class function6 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable6<
+              R , T0 , T1 , T2 , T3 , T4 , T5>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 6;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 6;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type;
+    typedef function6 self_type;
+    function6() : function_base() { }
+    template<typename Functor>
+    function6(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function6(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function6(clear_type*) : function_base() { }
+    function6(const function6& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function6() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function6&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function6& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function6& operator=(const function6& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function6& other)
+    {
+      if (&other == this)
+        return;
+      function6 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function6& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker6<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker6<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function6& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  inline void swap(function6<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5
+                   >& f1,
+                   function6<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  void operator==(const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&,
+                  const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+  void operator!=(const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>&,
+                  const function6<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5)>
+  : public function6<R , T0 , T1 , T2 , T3 , T4 , T5>
+{
+  typedef function6<R , T0 , T1 , T2 , T3 , T4 , T5> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+        >
+      struct function_invoker7
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+        >
+      struct void_function_invoker7
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_obj_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct void_function_obj_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_ref_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct void_function_ref_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_mem_invoker7
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct function_void_mem_invoker7
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+      >
+      struct get_function_invoker7
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker7<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_invoker7<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_function_obj_invoker7
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_obj_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_function_ref_invoker7
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_ref_invoker7<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+       >
+      struct get_member_invoker7
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker7<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >,
+                          function_mem_invoker7<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker7 { };
+      template<>
+      struct get_invoker7<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_invoker7<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker7<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker7<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_member_invoker7<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker7<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker7<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker7<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker7<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker7<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker7<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker7<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+      struct basic_vtable7
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+  >
+  class function7 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable7<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 7;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 7;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type;
+    typedef function7 self_type;
+    function7() : function_base() { }
+    template<typename Functor>
+    function7(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function7(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function7(clear_type*) : function_base() { }
+    function7(const function7& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function7() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function7&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function7& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function7& operator=(const function7& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function7& other)
+    {
+      if (&other == this)
+        return;
+      function7 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function7& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker7<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker7<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function7& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  inline void swap(function7<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6
+                   >& f1,
+                   function7<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  void operator==(const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
+                  const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+  void operator!=(const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>&,
+                  const function7<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
+  : public function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+{
+  typedef function7<R , T0 , T1 , T2 , T3 , T4 , T5 , T6> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+        >
+      struct function_invoker8
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+        >
+      struct void_function_invoker8
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_obj_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct void_function_obj_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_ref_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct void_function_ref_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_mem_invoker8
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct function_void_mem_invoker8
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+      >
+      struct get_function_invoker8
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker8<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_invoker8<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_function_obj_invoker8
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_obj_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_function_ref_invoker8
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_ref_invoker8<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+       >
+      struct get_member_invoker8
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker8<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >,
+                          function_mem_invoker8<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker8 { };
+      template<>
+      struct get_invoker8<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_invoker8<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker8<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker8<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_member_invoker8<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker8<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker8<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker8<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker8<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker8<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker8<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker8<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+      struct basic_vtable8
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+  >
+  class function8 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable8<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 8;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 8;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type;
+    typedef function8 self_type;
+    function8() : function_base() { }
+    template<typename Functor>
+    function8(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function8(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function8(clear_type*) : function_base() { }
+    function8(const function8& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function8() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function8&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function8& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function8& operator=(const function8& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function8& other)
+    {
+      if (&other == this)
+        return;
+      function8 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function8& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker8<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker8<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function8& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  inline void swap(function8<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                   >& f1,
+                   function8<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  void operator==(const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
+                  const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+  void operator!=(const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>&,
+                  const function8<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
+  : public function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+{
+  typedef function8<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+        >
+      struct function_invoker9
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+        >
+      struct void_function_invoker9
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_obj_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct void_function_obj_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_ref_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct void_function_ref_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_mem_invoker9
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct function_void_mem_invoker9
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+      >
+      struct get_function_invoker9
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker9<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_invoker9<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_function_obj_invoker9
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_obj_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_function_ref_invoker9
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_ref_invoker9<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+       >
+      struct get_member_invoker9
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker9<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >,
+                          function_mem_invoker9<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker9 { };
+      template<>
+      struct get_invoker9<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_invoker9<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker9<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker9<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_member_invoker9<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker9<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker9<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker9<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker9<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker9<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker9<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker9<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+      struct basic_vtable9
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+  >
+  class function9 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable9<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 9;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 9;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type;
+    typedef function9 self_type;
+    function9() : function_base() { }
+    template<typename Functor>
+    function9(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function9(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function9(clear_type*) : function_base() { }
+    function9(const function9& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function9() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function9&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function9& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function9& operator=(const function9& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function9& other)
+    {
+      if (&other == this)
+        return;
+      function9 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function9& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker9<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker9<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function9& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  inline void swap(function9<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                   >& f1,
+                   function9<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  void operator==(const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
+                  const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+  void operator!=(const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>&,
+                  const function9<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)>
+  : public function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+{
+  typedef function9<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+        >
+      struct function_invoker10
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+        >
+      struct void_function_invoker10
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_obj_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct void_function_obj_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_ref_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct void_function_ref_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_mem_invoker10
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct function_void_mem_invoker10
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9)
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+        }
+      };
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+      >
+      struct get_function_invoker10
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker10<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_invoker10<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_function_obj_invoker10
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_obj_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_function_ref_invoker10
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_ref_invoker10<
+                            FunctionObj,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+       >
+      struct get_member_invoker10
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker10<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >,
+                          function_mem_invoker10<
+                            MemberPtr,
+                            R ,
+                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                          >
+                       >::type type;
+      };
+      template<typename Tag>
+      struct get_invoker10 { };
+      template<>
+      struct get_invoker10<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_invoker10<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker10<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker10<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_member_invoker10<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker10<
+                             MemberPtr,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker10<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker10<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker10<
+                             FunctionObj,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+      template<>
+      struct get_invoker10<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker10<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker10<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                           >::type
+            invoker_type;
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+      template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+      struct basic_vtable10
+      {
+        typedef R result_type;
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9);
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+        void clear(function_buffer& functor) const
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+      private:
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        {
+          this->clear(functor);
+          if (f) {
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to(boost::mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        {
+          if (f) {
+            this->assign_to_a(boost::mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        {
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag) const
+        {
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+  template<
+    typename R ,
+    typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+  >
+  class function10 : public function_base
+  {
+  public:
+    typedef R result_type;
+  private:
+    typedef boost::detail::function::basic_vtable10<
+              R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+      vtable_type;
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
+    }
+    struct clear_type {};
+  public:
+    static const int args = 10;
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+    static const int arity = 10;
+    typedef T0 arg1_type; typedef T1 arg2_type; typedef T2 arg3_type; typedef T3 arg4_type; typedef T4 arg5_type; typedef T5 arg6_type; typedef T6 arg7_type; typedef T7 arg8_type; typedef T8 arg9_type; typedef T9 arg10_type;
+    typedef function10 self_type;
+    function10() : function_base() { }
+    template<typename Functor>
+    function10(Functor f
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function10(Functor f, Allocator a
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+    function10(clear_type*) : function_base() { }
+    function10(const function10& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+    ~function10() { clear(); }
+    result_type operator()( T0 a0 , T1 a1 , T2 a2 , T3 a3 , T4 a4 , T5 a5 , T6 a6 , T7 a7 , T8 a8 , T9 a9) const
+    {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+      return get_vtable()->invoker
+               (this->functor , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+    template<typename Functor>
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function10&>::type
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+    function10& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+    function10& operator=(const function10& f)
+    {
+      if (&f == this)
+        return *this;
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    void swap(function10& other)
+    {
+      if (&other == this)
+        return;
+      function10 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+  private:
+    struct dummy {
+      void nonnull() {}
+    };
+    typedef void (dummy::*safe_bool)();
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+    bool operator!() const
+      { return this->empty(); }
+  private:
+    void assign_to_own(const function10& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker10<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker10<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9,
+                         Allocator>
+        handler_type;
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+    void move_assign(function10& f)
+    {
+      if (&f == this)
+        return;
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+  template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  inline void swap(function10<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                   >& f1,
+                   function10<
+                     R ,
+                     T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  void operator==(const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
+                  const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&);
+template<typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+  void operator!=(const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>&,
+                  const function10<
+                          R ,
+                          T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>& );
+template<typename R ,
+         typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+class function<R ( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)>
+  : public function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+{
+  typedef function10<R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> base_type;
+  typedef function self_type;
+  struct clear_type {};
+public:
+  function() : base_type() {}
+  template<typename Functor>
+  function(Functor f
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+           ) :
+    base_type(f,a)
+  {
+  }
+  function(clear_type*) : base_type() {}
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  template<typename Functor>
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+}
+namespace boost { namespace mpl {
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20
+    >
+struct vector21
+    : v_item<
+          T20
+        , vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >
+        >
+{
+    typedef vector21 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21
+    >
+struct vector22
+    : v_item<
+          T21
+        , vector21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 >
+        >
+{
+    typedef vector22 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22
+    >
+struct vector23
+    : v_item<
+          T22
+        , vector22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 >
+        >
+{
+    typedef vector23 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23
+    >
+struct vector24
+    : v_item<
+          T23
+        , vector23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 >
+        >
+{
+    typedef vector24 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    >
+struct vector25
+    : v_item<
+          T24
+        , vector24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 >
+        >
+{
+    typedef vector25 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    , typename T25
+    >
+struct vector26
+    : v_item<
+          T25
+        , vector25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 >
+        >
+{
+    typedef vector26 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    , typename T25, typename T26
+    >
+struct vector27
+    : v_item<
+          T26
+        , vector26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 >
+        >
+{
+    typedef vector27 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    , typename T25, typename T26, typename T27
+    >
+struct vector28
+    : v_item<
+          T27
+        , vector27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 >
+        >
+{
+    typedef vector28 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    , typename T25, typename T26, typename T27, typename T28
+    >
+struct vector29
+    : v_item<
+          T28
+        , vector28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 >
+        >
+{
+    typedef vector29 type;
+};
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    , typename T20, typename T21, typename T22, typename T23, typename T24
+    , typename T25, typename T26, typename T27, typename T28, typename T29
+    >
+struct vector30
+    : v_item<
+          T29
+        , vector29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 >
+        >
+{
+    typedef vector30 type;
+};
+}}
+namespace boost { namespace function_types { namespace detail {
+using mpl::placeholders::_;
+template<typename T, typename L>
+struct class_transform
+{ typedef typename mpl::apply1<L,T>::type type; };
+template<typename T> struct class_transform< T, mpl::identity<_> >
+{ typedef T type; };
+template<typename T> struct class_transform< T, add_reference<_> >
+{ typedef T & type; };
+template<typename T> struct class_transform< T, add_pointer<_> >
+{ typedef T * type; };
+template<typename T> struct class_transform< T, remove_cv<_> >
+{ typedef typename boost::remove_cv<T>::type type; };
+template<typename T> struct class_transform< T, add_reference< remove_cv<_> > >
+{ typedef typename boost::remove_cv<T>::type & type; };
+template<typename T> struct class_transform< T, add_pointer< remove_cv<_> > >
+{ typedef typename boost::remove_cv<T>::type * type; };
+template<typename T, typename U> struct class_transform< T, mpl::always<U> >
+{ typedef U type; };
+} } }
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct bitxor_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct bitxor_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct bitxor_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct bitxor_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct bitxor_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct bitxor_
+    : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5>
+{
+};
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct bitxor_< N1,N2,N3,N4,na >
+    : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>
+{
+};
+template<
+      typename N1, typename N2, typename N3
+    >
+struct bitxor_< N1,N2,N3,na,na >
+    : bitxor_< bitxor_< N1,N2 >, N3>
+{
+};
+template<
+      typename N1, typename N2
+    >
+struct bitxor_< N1,N2,na,na,na >
+    : bitxor_impl<
+          typename bitxor_tag<N1>::type
+        , typename bitxor_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct bitxor_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : bitxor_< T1 , T2 > { }; }; template< typename Tag > struct lambda< bitxor_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef bitxor_< na , na > result_; typedef bitxor_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bitxor_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< bitxor_< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct bitxor_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  ^ N2::value
+                )
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace function_types {
+namespace detail
+{
+  typedef long bits_t;
+  template<bits_t Value> struct constant
+    : boost::integral_constant<bits_t,Value>
+  { };
+  template<bits_t Bits, bits_t Mask> struct property_tag
+  {
+    typedef constant<Bits> bits;
+    typedef constant<Mask> mask;
+  };
+  template<typename T> struct bits : T::bits { };
+  template<typename T> struct mask : T::mask { };
+  template<bits_t Bits, bits_t CCID> struct encode_bits_impl;
+  template<bits_t LHS_bits, bits_t LHS_mask,
+           bits_t RHS_bits, bits_t RHS_mask>
+  struct tag_ice;
+  template<class Tag, class RegTag = Tag> struct retag_default_cc;
+  template<bits_t Bits, bits_t CCID> struct encode_bits
+    : constant<
+        ::boost::function_types::detail::encode_bits_impl<Bits,CCID>::value
+      >
+  { };
+  template<class LHS, class RHS> struct compound_tag
+  {
+    typedef constant<
+      ::boost::function_types::detail::tag_ice
+        < ::boost::function_types::detail::bits<LHS>::value
+        , ::boost::function_types::detail::mask<LHS>::value
+        , ::boost::function_types::detail::bits<RHS>::value
+        , ::boost::function_types::detail::mask<RHS>::value
+        >::combined_bits
+    > bits;
+    typedef constant<
+      ::boost::function_types::detail::tag_ice
+        < ::boost::function_types::detail::bits<LHS>::value
+        , ::boost::function_types::detail::mask<LHS>::value
+        , ::boost::function_types::detail::bits<RHS>::value
+        , ::boost::function_types::detail::mask<RHS>::value
+        >::combined_mask
+    > mask;
+  };
+  template <class Base, class PropOld, class PropNew>
+  struct changed_tag
+    : Base
+  {
+    typedef mpl::bitxor_
+        <typename Base::bits, typename PropOld::bits, typename PropNew::bits>
+    bits;
+  };
+  template<class Tag, class QueryTag> struct represents_impl
+    : boost::integral_constant<bool,
+        ::boost::function_types::detail::tag_ice
+          < ::boost::function_types::detail::bits<Tag>::value
+          , ::boost::function_types::detail::mask<Tag>::value
+          , ::boost::function_types::detail::bits<QueryTag>::value
+          , ::boost::function_types::detail::mask<QueryTag>::value
+          >::match
+      >
+  { };
+}
+typedef detail::property_tag<0,0> null_tag;
+template<class Tag1, class Tag2, class Tag3 = null_tag, class Tag4 = null_tag>
+struct tag
+  : detail::compound_tag< detail::compound_tag<Tag1,Tag2>,
+        detail::compound_tag<Tag3,Tag4> >
+{ };
+template<class Tag1, class Tag2, class Tag3> struct tag<Tag1,Tag2,Tag3,null_tag>
+  : detail::compound_tag<detail::compound_tag<Tag1,Tag2>,Tag3>
+{ };
+template<class Tag1, class Tag2> struct tag<Tag1,Tag2,null_tag,null_tag>
+  : detail::compound_tag<Tag1,Tag2>
+{ };
+template<class Tag1> struct tag<Tag1,null_tag,null_tag,null_tag>
+  : Tag1
+{ };
+template<class Tag, class QueryTag> struct represents
+  : detail::represents_impl<Tag, detail::retag_default_cc<QueryTag,Tag> >
+{ };
+template<class Tag, class QueryTag> struct extract
+{
+  typedef detail::constant<
+    ::boost::function_types::detail::tag_ice
+      < ::boost::function_types::detail::bits<Tag>::value
+      , ::boost::function_types::detail::mask<Tag>::value
+      , ::boost::function_types::detail::bits<QueryTag>::value
+      , ::boost::function_types::detail::mask<QueryTag>::value
+      >::extracted_bits
+  > bits;
+  typedef detail::constant<
+    ::boost::function_types::detail::mask<QueryTag>::value
+  > mask;
+};
+} }
+namespace boost { namespace function_types {
+typedef detail::property_tag<0x00000200,0x00000300> non_variadic;
+typedef detail::property_tag<0x00000100,0x00000300> variadic;
+typedef detail::property_tag<0,0x00000400> non_const;
+typedef detail::property_tag<0x00000400,0x00000400> const_qualified;
+typedef detail::property_tag<0,0x00000800> non_volatile;
+typedef detail::property_tag<0x00000800,0x00000800> volatile_qualified;
+typedef detail::property_tag<0x00008000,0x00ff8000> default_cc;
+typedef detail::property_tag<0 , 3072> non_cv;
+typedef detail::property_tag<0x00000400 , 3072> const_non_volatile;
+typedef detail::property_tag<0x00000800, 3072> volatile_non_const;
+typedef detail::property_tag<3072 , 3072> cv_qualified;
+namespace detail {
+typedef constant<0x00ff0fff> full_mask;
+template <bits_t Flags, bits_t CCID> struct encode_bits_impl
+{
+static const bits_t value = Flags | (0x00008000 * CCID) << 1
+                                  ;
+};
+template <bits_t Flags, bits_t CCID, std::size_t Arity>
+struct encode_charr_impl
+{
+static const std::size_t value = (std::size_t)(1+ Flags | (0x00008000 * CCID) << 1 | Arity << 24 )
+  ;
+};
+template <bits_t Bits> struct decode_bits
+{
+static const bits_t flags = Bits & 0x00000fff;
+static const bits_t cc_id = ( (Bits & 0x00ff0fff) / 0x00008000) >> 1
+ ;
+static const bits_t tag_bits = (Bits & 0x00ff0fff);
+static const std::size_t arity = (std::size_t) (Bits >> 24)
+ ;
+};
+template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
+struct tag_ice
+{
+static const bool match = RHS_bits == (LHS_bits & RHS_mask & (RHS_bits | ~0x000000ff))
+ ;
+static const bits_t combined_bits = (LHS_bits & ~RHS_mask) | RHS_bits
+ ;
+static const bits_t combined_mask = LHS_mask | RHS_mask
+ ;
+static const bits_t extracted_bits = LHS_bits & RHS_mask
+ ;
+};
+typedef property_tag<0x00000001,0x000000ff> callable_builtin_tag;
+typedef property_tag<0x00000003,0x000000ff> nonmember_callable_builtin_tag;
+typedef property_tag<0x00000007,0x000000ff> function_tag;
+typedef property_tag<0x00000013,0x000000ff> reference_tag;
+typedef property_tag<0x0000000b,0x000000ff> pointer_tag;
+typedef property_tag<0x00000061,0x000000ff> member_function_pointer_tag;
+typedef property_tag<0x000000a3,0x000000ff> member_object_pointer_tag;
+typedef property_tag<0x000002a3,0x00ff0fff> member_object_pointer_base;
+typedef property_tag<0x00000020,0x000000ff> member_pointer_tag;
+typedef property_tag< 33287 , 16745471 > nv_dcc_func;
+typedef property_tag< 33377 , 16745471 > nv_dcc_mfp;
+}
+} }
+namespace boost { namespace function_types {
+  struct implicit_cc
+  {
+    typedef detail::encode_bits<0,1> bits;
+    typedef detail::constant<0x00ff8000> mask;
+  };
+} }
+namespace boost
+{
+  namespace function_types
+  {
+    using mpl::placeholders::_;
+    template< typename T, typename ClassTypeTransform = add_reference<_> >
+    struct components;
+    namespace detail
+    {
+      template<typename T, typename L> struct components_impl;
+    }
+    template<typename T, typename ClassTypeTransform>
+    struct components
+      : detail::components_impl<T, ClassTypeTransform>
+    {
+      typedef components<T,ClassTypeTransform> type;
+    };
+  namespace detail {
+    struct components_mpl_sequence_tag;
+    struct components_non_func_base
+    {
+      typedef mpl::vector0<> types;
+      typedef void function_arity;
+      typedef detail::constant<0> bits;
+      typedef detail::constant<0> mask;
+      typedef components_mpl_sequence_tag tag;
+    };
+    template
+    < typename Components
+    , typename IfTagged
+    , typename ThenTag
+    , typename DefaultBase = components_non_func_base
+    >
+    struct retagged_if
+      : mpl::if_
+        < detail::represents_impl<Components, IfTagged>
+        , detail::changed_tag<Components,IfTagged,ThenTag>
+        , DefaultBase
+        >::type
+    { };
+    template<typename T, typename L>
+    struct components_impl
+      : detail::retagged_if
+        < detail::components_impl<T*,L>
+        , pointer_tag, function_tag >
+    { };
+    template<typename T, typename L>
+    struct components_impl<T&, L>
+      : detail::retagged_if
+        < detail::components_impl<T*,L>
+        , pointer_tag, reference_tag >
+    { };
+    template<typename T, typename L>
+    struct components_impl<T*, L>
+      : components_non_func_base
+    { };
+    template<typename T, typename L>
+    struct components_impl<T* const, L>
+      : components_impl<T*,L>
+    { };
+    template<typename T, typename L>
+    struct components_impl<T* volatile, L>
+      : components_impl<T*,L>
+    { };
+    template<typename T, typename L>
+    struct components_impl<T* const volatile, L>
+      : components_impl<T*,L>
+    { };
+    template<typename T, typename L>
+    struct components_impl<T const, L>
+      : components_impl<T,L>
+    { };
+    template<typename T, typename L>
+    struct components_impl<T volatile, L>
+      : components_impl<T,L>
+    { };
+    template<typename T, typename L>
+    struct components_impl<T const volatile, L>
+      : components_impl<T,L>
+    { };
+    template<typename T, class C>
+    struct member_obj_ptr_result
+    { typedef T & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C const>
+    { typedef T const & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C volatile>
+    { typedef T volatile & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C const volatile>
+    { typedef T const volatile & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C>
+    { typedef T & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C const>
+    { typedef T & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C volatile>
+    { typedef T & type; };
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C const volatile>
+    { typedef T & type; };
+    template<typename T, class C, typename L>
+    struct member_obj_ptr_components
+      : member_object_pointer_base
+    {
+      typedef function_types::components<T C::*, L> type;
+      typedef components_mpl_sequence_tag tag;
+      typedef mpl::integral_c<std::size_t,1> function_arity;
+      typedef mpl::vector2< typename detail::member_obj_ptr_result<T,C>::type,
+          typename detail::class_transform<C,L>::type > types;
+    };
+    template<typename T, class C, typename L>
+    struct components_impl<T C::*, L>
+      : member_obj_ptr_components<T,C,L>
+    { };
+template< typename R, typename L>
+struct components_impl<R ( * ) ( ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) ( ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,0> function_arity;
+typedef mpl::vector1< R > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( * ) (T0 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R , T0 > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( * ) (T0 , T1 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R , T0 , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R , T0 , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R , T0 , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R , T0 , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R , T0 , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L>
+{
+typedef encode_bits<523,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R, typename L>
+struct components_impl<R ( * ) ( ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) ( ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,0> function_arity;
+typedef mpl::vector1< R > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( * ) (T0 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R , T0 > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( * ) (T0 , T1 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R , T0 , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R , T0 , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R , T0 , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R , T0 , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R , T0 , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L>
+{
+typedef encode_bits<267,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( * ) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 , L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 , L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 , L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L>
+{
+typedef encode_bits<609,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 , L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 , L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 , L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L>
+{
+typedef encode_bits<353,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) , L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 , L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 const, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 const, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 const, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const, L>
+{
+typedef encode_bits<1633,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 const, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 const, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 const, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const, L>
+{
+typedef encode_bits<1377,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 const, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 volatile, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 volatile, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) volatile, L>
+{
+typedef encode_bits<2657,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 volatile, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 volatile, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile, L>
+{
+typedef encode_bits<2401,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 const volatile, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 const volatile, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const volatile, L>
+{
+typedef encode_bits<3681,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<R ( T0::* ) ( ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) ( ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 const volatile, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<R ( T0::* ) (T1 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 const volatile, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19, typename L>
+struct components_impl<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile, L>
+{
+typedef encode_bits<3425,1> bits;
+typedef constant<0x00ff0fff> mask;
+typedef function_types::components<R ( T0::* ) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 const volatile, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+  } }
+}
+namespace boost { namespace mpl {
+template<> struct size_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::size <typename S::types>
+  { };
+};
+template<> struct empty_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::empty <typename S::types>
+  { };
+};
+template<> struct front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::front <typename S::types>
+  { };
+};
+template<> struct back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::back <typename S::types>
+  { };
+};
+template<> struct at_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename N > struct apply
+    : mpl::at <typename S::types, N >
+  { };
+};
+template<> struct begin_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::begin <typename S::types>
+  { };
+};
+template<> struct end_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::end <typename S::types>
+  { };
+};
+template<> struct clear_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::clear< typename S::types >::type types;
+  };
+};
+template<>
+struct push_front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename T >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::push_front< typename S::types, T >::type types;
+  };
+};
+template<>
+struct pop_front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::pop_front< typename S::types >::type types;
+  };
+};
+template<>
+struct push_back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename T >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::push_back< typename S::types, T >::type types;
+  };
+};
+template<>
+struct pop_back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::pop_back< typename S::types >::type types;
+  };
+};
+} }
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct bitand_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct bitand_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct bitand_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct bitand_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct bitand_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct bitand_
+    : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5>
+{
+};
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct bitand_< N1,N2,N3,N4,na >
+    : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>
+{
+};
+template<
+      typename N1, typename N2, typename N3
+    >
+struct bitand_< N1,N2,N3,na,na >
+    : bitand_< bitand_< N1,N2 >, N3>
+{
+};
+template<
+      typename N1, typename N2
+    >
+struct bitand_< N1,N2,na,na,na >
+    : bitand_impl<
+          typename bitand_tag<N1>::type
+        , typename bitand_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct bitand_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : bitand_< T1 , T2 > { }; }; template< typename Tag > struct lambda< bitand_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef bitand_< na , na > result_; typedef bitand_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bitand_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< bitand_< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct bitand_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  & N2::value
+                )
+            >
+    {
+    };
+};
+}}
+namespace boost { namespace function_types {
+namespace detail
+{
+template<class Tag, class RefTag> struct selector_bits
+{
+static const bits_t value = ( (::boost::function_types::detail::bits<Tag> ::value & 0x00008000) | (::boost::function_types::detail::bits<RefTag> ::value & 802) )
+  ;
+};
+template<bits_t SelectorBits> struct default_cc_tag;
+template<class Tag, class RefTag> struct retag_default_cc
+: detail::compound_tag
+< Tag, detail::default_cc_tag<
+::boost::function_types::detail::selector_bits<Tag,RefTag> ::value > >
+{ };
+template<bits_t SelectorBits> struct default_cc_tag
+{
+typedef null_tag::bits bits;
+typedef null_tag::mask mask;
+};
+class test_class;
+typedef constant<0x00ff8000> cc_mask_constant;
+template< > struct default_cc_tag<33282>
+{
+typedef void ( *tester)();
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33026>
+{
+typedef void ( *tester)( ... );
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33312>
+{
+typedef void (test_class:: *tester)();
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33056>
+{
+typedef void (test_class:: *tester)( ... );
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+} } }
+namespace boost
+{
+  namespace function_types
+  {
+    template< typename T, typename Tag = null_tag >
+    struct is_function
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::function_tag>
+        >
+    {
+    };
+  }
+}
+namespace boost
+{
+  namespace function_types
+  {
+    template< typename T, typename Tag = null_tag >
+    struct is_callable_builtin
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag, detail::callable_builtin_tag>
+        >
+    {
+    };
+  }
+}
+namespace boost
+{
+  namespace function_types
+  {
+    using mpl::placeholders::_;
+    template< typename T, typename ClassTypeTransform = add_reference<_> >
+    struct parameter_types;
+    namespace detail
+    {
+      template<typename T, typename ClassTypeTransform>
+      struct parameter_types_impl
+        : mpl::pop_front
+          < typename function_types::components<T,ClassTypeTransform>::types
+          >::type
+      { };
+    }
+    template<typename T, typename ClassTypeTransform> struct parameter_types
+      : mpl::if_
+        < function_types::is_callable_builtin<T>
+        , detail::parameter_types_impl<T,ClassTypeTransform>, boost::blank
+        >::type
+    {
+    };
+  }
+}
+namespace boost
+{
+  namespace function_types
+  {
+    template< typename T > struct result_type;
+    namespace detail
+    {
+      template<typename T> struct result_type_impl
+        : mpl::at_c
+          < typename function_types::components<T>::types, 0 >
+      { };
+    }
+    template<typename T> struct result_type
+      : mpl::if_
+        < function_types::is_callable_builtin<T>
+        , detail::result_type_impl<T>, boost::blank
+        >::type
+    {
+    };
+  }
+}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Types, typename Pred, typename Default>
+    struct extract_param
+    {
+        typedef typename mpl::find_if<Types, Pred>::type pos;
+        typedef typename
+            mpl::eval_if<
+                is_same<pos, typename mpl::end<Types>::type>
+              , mpl::identity<Default>
+              , mpl::deref<pos>
+            >::type
+        type;
+    };
+    template <typename Types>
+    struct extract_locals
+      : fusion::result_of::as_vector<
+            typename extract_param<
+                Types
+              , is_locals<mpl::_>
+              , locals<>
+            >::type
+        >
+    {};
+    template <typename Domain, typename Types>
+    struct extract_component
+      : spirit::result_of::compile<
+            Domain
+          , typename extract_param<
+                Types
+              , traits::matches<Domain, mpl::_>
+              , unused_type
+            >::type
+        >
+    {};
+    template <typename Types>
+    struct extract_sig
+      : extract_param<
+            Types
+          , function_types::is_function<mpl::_>
+          , void()
+        >
+    {};
+    template <typename Sig>
+    struct attr_from_sig
+    {
+        typedef typename function_types::result_type<Sig>::type attr;
+        typedef typename
+            mpl::if_<
+                is_same<attr, void>
+              , unused_type
+              , attr
+            >::type
+        type;
+    };
+    template <typename Sig>
+    struct params_from_sig
+    {
+        typedef typename function_types::parameter_types<Sig>::type params;
+        typedef typename fusion::result_of::as_list<params>::type type;
+    };
+    template <typename Types>
+    struct extract_encoding
+      : extract_param<
+            Types
+          , is_char_encoding<mpl::_>
+          , unused_type
+        >
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct reference : parser<reference<Subject> >
+    {
+        typedef Subject subject_type;
+        reference(Subject& subject)
+          : ref(subject) {}
+        template <typename Context, typename Iterator>
+        struct attribute : Subject::template attribute<Context, Iterator> {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return ref.get().parse(first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return ref.get().what(context);
+        }
+        boost::reference_wrapper<Subject> ref;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::reference<Subject>, Attribute, Context
+      , Iterator>
+      : handles_container<typename remove_const<Subject>::type
+        , Attribute, Context, Iterator>
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject, typename Params>
+    struct parameterized_nonterminal
+      : parser<parameterized_nonterminal<Subject, Params> >
+    {
+        parameterized_nonterminal(Subject const& subject, Params const& params)
+          : ref(subject), params(params)
+        {
+        }
+        template <typename Context, typename Iterator>
+        struct attribute
+          : Subject::template attribute<Context, Iterator> {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return ref.get().parse(first, last, context, skipper, attr, params);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return ref.get().what(context);
+        }
+        boost::reference_wrapper<Subject const> ref;
+        Params params;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename Params, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::parameterized_nonterminal<Subject, Params>
+          , Attribute, Context, Iterator>
+      : handles_container<typename remove_const<Subject>::type
+        , Attribute, Context, Iterator>
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Parser, typename Auto>
+    struct parser_binder
+    {
+        parser_binder(Parser const& p)
+          : p(p) {}
+        template <typename Iterator, typename Skipper, typename Context>
+        bool call(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, mpl::true_) const
+        {
+            return p.parse(first, last, context, skipper, unused);
+        }
+        template <typename Iterator, typename Skipper, typename Context>
+        bool call(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, mpl::false_) const
+        {
+            return p.parse(first, last, context, skipper
+                , fusion::at_c<0>(context.attributes));
+        }
+        template <typename Iterator, typename Skipper, typename Context>
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            typedef typename traits::has_semantic_action<Parser>::type auto_rule;
+            return call(first, last, context, skipper, auto_rule());
+        }
+        Parser p;
+    };
+    template <typename Parser>
+    struct parser_binder<Parser, mpl::true_>
+    {
+        parser_binder(Parser const& p)
+          : p(p) {}
+        template <typename Iterator, typename Skipper, typename Context>
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            return p.parse(first, last, context, skipper
+                , fusion::at_c<0>(context.attributes));
+        }
+        Parser p;
+    };
+    template <typename Auto, typename Parser>
+    inline parser_binder<Parser, Auto>
+    bind_parser(Parser const& p)
+    {
+        return parser_binder<Parser, Auto>(p);
+    }
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Iterator, typename T1 = unused_type
+      , typename T2 = unused_type, typename T3 = unused_type
+      , typename T4 = unused_type>
+    struct rule;
+    template <
+        typename Iterator, typename T1 = unused_type
+      , typename T2 = unused_type, typename T3 = unused_type
+      , typename T4 = unused_type>
+    struct grammar;
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::_r0_type; using spirit::_r0; using spirit::_r1_type; using spirit::_r1; using spirit::_r2_type; using spirit::_r2; using spirit::_r3_type; using spirit::_r3; using spirit::_r4_type; using spirit::_r4; using spirit::_r5_type; using spirit::_r5; using spirit::_r6_type; using spirit::_r6; using spirit::_r7_type; using spirit::_r7; using spirit::_r8_type; using spirit::_r8; using spirit::_r9_type; using spirit::_r9;
+    using spirit::_pass_type;
+    using spirit::_val_type;
+    using spirit::_a_type;
+    using spirit::_b_type;
+    using spirit::_c_type;
+    using spirit::_d_type;
+    using spirit::_e_type;
+    using spirit::_f_type;
+    using spirit::_g_type;
+    using spirit::_h_type;
+    using spirit::_i_type;
+    using spirit::_j_type;
+    using spirit::_pass;
+    using spirit::_val;
+    using spirit::_a;
+    using spirit::_b;
+    using spirit::_c;
+    using spirit::_d;
+    using spirit::_e;
+    using spirit::_f;
+    using spirit::_g;
+    using spirit::_h;
+    using spirit::_i;
+    using spirit::_j;
+    using spirit::info;
+    using spirit::locals;
+    template <
+        typename Iterator, typename T1, typename T2, typename T3
+      , typename T4>
+    struct rule
+      : proto::extends<
+            typename proto::terminal<
+                reference<rule<Iterator, T1, T2, T3, T4> const>
+            >::type
+          , rule<Iterator, T1, T2, T3, T4>
+        >
+      , parser<rule<Iterator, T1, T2, T3, T4> >
+    {
+        typedef Iterator iterator_type;
+        typedef rule<Iterator, T1, T2, T3, T4> this_type;
+        typedef reference<this_type const> reference_;
+        typedef typename proto::terminal<reference_>::type terminal;
+        typedef proto::extends<terminal, this_type> base_type;
+        typedef mpl::vector<T1, T2, T3, T4> template_params;
+        typedef typename
+            spirit::detail::extract_locals<template_params>::type
+        locals_type;
+        typedef typename
+            spirit::detail::extract_component<
+                qi::domain, template_params>::type
+        skipper_type;
+        typedef typename
+            spirit::detail::extract_sig<template_params>::type
+        sig_type;
+        typedef typename
+            spirit::detail::extract_encoding<template_params>::type
+        encoding_type;
+        typedef typename
+            spirit::detail::attr_from_sig<sig_type>::type
+        attr_type;
+        typedef typename add_reference<attr_type>::type attr_reference_type;
+        typedef typename
+            spirit::detail::params_from_sig<sig_type>::type
+        parameter_types;
+        static size_t const params_size =
+            fusion::result_of::size<parameter_types>::type::value;
+        typedef context<
+            fusion::cons<attr_reference_type, parameter_types>
+          , locals_type>
+        context_type;
+        typedef function<
+            bool(Iterator& first, Iterator const& last
+              , context_type& context
+              , skipper_type const& skipper
+            )>
+        function_type;
+        typedef typename
+            mpl::if_<
+                is_same<encoding_type, unused_type>
+              , unused_type
+              , tag::char_code<tag::encoding, encoding_type>
+            >::type
+        encoding_modifier_type;
+        explicit rule(std::string const& name_ = "unnamed-rule")
+          : base_type(terminal::make(reference_(*this)))
+          , name_(name_)
+        {
+        }
+        rule(rule const& rhs)
+          : base_type(terminal::make(reference_(*this)))
+          , name_(rhs.name_)
+          , f(rhs.f)
+        {
+        }
+        template <typename Auto, typename Expr>
+        static void define(rule& lhs, Expr const& expr, mpl::false_)
+        {
+            struct error_invalid_expression; typedef struct error_invalid_expression176 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg176; enum { mpl_assertion_in_line_176 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg176::assert_arg() ) ) };
+        }
+        template <typename Auto, typename Expr>
+        static void define(rule& lhs, Expr const& expr, mpl::true_)
+        {
+            lhs.f = detail::bind_parser<Auto>(
+                compile<qi::domain>(expr, encoding_modifier_type()));
+        }
+        template <typename Expr>
+        rule(Expr const& expr, std::string const& name_ = "unnamed-rule")
+          : base_type(terminal::make(reference_(*this)))
+          , name_(name_)
+        {
+            define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>());
+        }
+        rule& operator=(rule const& rhs)
+        {
+            (static_cast<void> (0));
+            f = rhs.f;
+            name_ = rhs.name_;
+            return *this;
+        }
+        std::string const& name() const
+        {
+            return name_;
+        }
+        void name(std::string const& str)
+        {
+            name_ = str;
+        }
+        template <typename Expr>
+        rule& operator=(Expr const& expr)
+        {
+            define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>());
+            return *this;
+        }
+        template <typename Expr>
+        friend rule& operator%=(rule& r, Expr const& expr)
+        {
+            define<mpl::true_>(r, expr, traits::matches<qi::domain, Expr>());
+            return r;
+        }
+        template <typename Expr>
+        friend rule& operator%=(rule& r, Expr& expr)
+        {
+            return r %= static_cast<Expr const&>(expr);
+        }
+        template <typename Context, typename Iterator_>
+        struct attribute
+        {
+            typedef attr_type type;
+        };
+        template <typename Context, typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            if (f)
+            {
+                if (is_same<skipper_type, unused_type>::value)
+                    qi::skip_over(first, last, skipper);
+                typedef traits::make_attribute<attr_type, Attribute> make_attribute;
+                typedef traits::transform_attribute<
+                    typename make_attribute::type, attr_type, domain>
+                transform;
+                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename transform::type attr_ = transform::pre(made_attr);
+                context_type context(attr_);
+                if (f(first, last, context, skipper))
+                {
+                    traits::post_transform(attr, attr_);
+                    return true;
+                }
+                traits::fail_transform(attr, attr_);
+            }
+            return false;
+        }
+        template <typename Context, typename Skipper
+          , typename Attribute, typename Params>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& caller_context, Skipper const& skipper
+          , Attribute& attr, Params const& params) const
+        {
+            if (f)
+            {
+                if (is_same<skipper_type, unused_type>::value)
+                    qi::skip_over(first, last, skipper);
+                typedef traits::make_attribute<attr_type, Attribute> make_attribute;
+                typedef traits::transform_attribute<
+                    typename make_attribute::type, attr_type, domain>
+                transform;
+                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename transform::type attr_ = transform::pre(made_attr);
+                context_type context(attr_, params, caller_context);
+                if (f(first, last, context, skipper))
+                {
+                    traits::post_transform(attr, attr_);
+                    return true;
+                }
+                traits::fail_transform(attr, attr_);
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info(name_);
+        }
+        reference_ alias() const
+        {
+            return reference_(*this);
+        }
+        typename proto::terminal<this_type>::type copy() const
+        {
+            typename proto::terminal<this_type>::type result = {*this};
+            return result;
+        }
+        rule const& get_parameterized_subject() const { return *this; }
+        typedef rule parameterized_subject_type;
+    template < typename A0>
+    typename lazy_enable_if_c<
+        (params_size == 1)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0> >
+        >
+    >::type
+    operator()( A0 const& f0) const
+    {
+        typedef fusion::vector< A0> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0))
+        );
+    }
+    template < typename A0 , typename A1>
+    typename lazy_enable_if_c<
+        (params_size == 2)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1) const
+    {
+        typedef fusion::vector< A0 , A1> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2>
+    typename lazy_enable_if_c<
+        (params_size == 3)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2) const
+    {
+        typedef fusion::vector< A0 , A1 , A2> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3>
+    typename lazy_enable_if_c<
+        (params_size == 4)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    typename lazy_enable_if_c<
+        (params_size == 5)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    typename lazy_enable_if_c<
+        (params_size == 6)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    typename lazy_enable_if_c<
+        (params_size == 7)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    typename lazy_enable_if_c<
+        (params_size == 8)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    typename lazy_enable_if_c<
+        (params_size == 9)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7 , A8 const& f8) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7 , f8))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    typename lazy_enable_if_c<
+        (params_size == 10)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7 , A8 const& f8 , A9 const& f9) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7 , f8 , f9))
+        );
+    }
+        std::string name_;
+        function_type f;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <
+        typename IteratorA, typename IteratorB, typename Attribute
+      , typename Context, typename T1, typename T2, typename T3, typename T4>
+    struct handles_container<
+        qi::rule<IteratorA, T1, T2, T3, T4>, Attribute, Context, IteratorB>
+      : traits::is_container<
+          typename attribute_of<
+              qi::rule<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+          >::type
+        >
+    {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Iterator, typename T1, typename T2, typename T3
+      , typename T4>
+    struct grammar
+      : proto::extends<
+            typename proto::terminal<
+                reference<rule<Iterator, T1, T2, T3, T4> const>
+            >::type
+          , grammar<Iterator, T1, T2, T3, T4>
+        >
+      , parser<grammar<Iterator, T1, T2, T3, T4> >
+      , noncopyable
+    {
+        typedef Iterator iterator_type;
+        typedef rule<Iterator, T1, T2, T3, T4> start_type;
+        typedef typename start_type::sig_type sig_type;
+        typedef typename start_type::locals_type locals_type;
+        typedef typename start_type::skipper_type skipper_type;
+        typedef typename start_type::encoding_type encoding_type;
+        typedef grammar<Iterator, T1, T2, T3, T4> base_type;
+        typedef reference<start_type const> reference_;
+        typedef typename proto::terminal<reference_>::type terminal;
+        static size_t const params_size = start_type::params_size;
+        template <typename Context, typename Iterator_>
+        struct attribute
+        {
+            typedef typename start_type::attr_type type;
+        };
+        grammar(
+            start_type const& start
+          , std::string const& name_ = "unnamed-grammar")
+        : proto::extends<terminal, base_type>(terminal::make(reference_(start)))
+        , name_(name_)
+        {}
+        template <typename Iterator_,
+            typename T1_, typename T2_, typename T3_, typename T4_>
+        grammar(
+            rule<Iterator_, T1_, T2_, T3_, T4_> const&
+          , std::string const& = "unnamed-grammar")
+        {
+            struct incompatible_start_rule; typedef struct
+ incompatible_start_rule77
+            : boost::mpl::assert_ { static boost::mpl::failed ************ (incompatible_start_rule::************ assert_arg()) (rule<Iterator_, T1_, T2_, T3_, T4_>) { return 0; } }
+ mpl_assert_arg77
+            ; enum { mpl_assertion_in_line_77 = sizeof( boost::mpl::assertion_failed<((is_same<start_type, rule<Iterator_, T1_, T2_, T3_, T4_> >::value))>( mpl_assert_arg77::assert_arg() ) ) }
+                                                                               ;
+        }
+        std::string name() const
+        {
+            return name_;
+        }
+        void name(std::string const& str)
+        {
+            name_ = str;
+        }
+        template <typename Context, typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return this->proto_base().child0.parse(
+                first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context&) const
+        {
+            return info(name_);
+        }
+        start_type const& get_parameterized_subject() const
+        { return this->proto_base().child0.ref.get(); }
+        typedef start_type parameterized_subject_type;
+    template < typename A0>
+    typename lazy_enable_if_c<
+        (params_size == 1)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0> >
+        >
+    >::type
+    operator()( A0 const& f0) const
+    {
+        typedef fusion::vector< A0> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0))
+        );
+    }
+    template < typename A0 , typename A1>
+    typename lazy_enable_if_c<
+        (params_size == 2)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1) const
+    {
+        typedef fusion::vector< A0 , A1> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2>
+    typename lazy_enable_if_c<
+        (params_size == 3)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2) const
+    {
+        typedef fusion::vector< A0 , A1 , A2> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3>
+    typename lazy_enable_if_c<
+        (params_size == 4)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    typename lazy_enable_if_c<
+        (params_size == 5)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    typename lazy_enable_if_c<
+        (params_size == 6)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    typename lazy_enable_if_c<
+        (params_size == 7)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    typename lazy_enable_if_c<
+        (params_size == 8)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    typename lazy_enable_if_c<
+        (params_size == 9)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7 , A8 const& f8) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7 , f8))
+        );
+    }
+    template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    typename lazy_enable_if_c<
+        (params_size == 10)
+      , proto::terminal<
+            spirit::qi::parameterized_nonterminal<
+                parameterized_subject_type
+              , fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
+        >
+    >::type
+    operator()( A0 const& f0 , A1 const& f1 , A2 const& f2 , A3 const& f3 , A4 const& f4 , A5 const& f5 , A6 const& f6 , A7 const& f7 , A8 const& f8 , A9 const& f9) const
+    {
+        typedef fusion::vector< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> vector_type;
+        typedef spirit::qi::parameterized_nonterminal<
+            parameterized_subject_type, vector_type> parameterized_type;
+        typedef typename proto::terminal<parameterized_type>::type result_type;
+        return result_type::make(
+            parameterized_type(
+                this->get_parameterized_subject()
+              , fusion::make_vector( f0 , f1 , f2 , f3 , f4 , f5 , f6 , f7 , f8 , f9))
+        );
+    }
+        std::string name_;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <
+        typename IteratorA, typename IteratorB, typename Attribute
+      , typename Context, typename T1, typename T2, typename T3, typename T4>
+    struct handles_container<
+        qi::grammar<IteratorA, T1, T2, T3, T4>, Attribute, Context, IteratorB>
+      : traits::is_container<
+          typename attribute_of<
+              qi::grammar<IteratorA, T1, T2, T3, T4>, Context, IteratorB
+          >::type
+        >
+    {};
+}}}
+namespace boost { namespace fusion
+{
+    template <typename Seq1, typename Seq2>
+    inline bool
+    equal_to(Seq1 const& a, Seq2 const& b)
+    {
+        return result_of::size<Seq1>::value == result_of::size<Seq2>::value
+            && detail::sequence_equal_to<
+            Seq1 const, Seq2 const
+            , result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
+            call(fusion::begin(a), fusion::begin(b));
+    }
+    namespace operators
+    {
+        template <typename Seq1, typename Seq2>
+        inline typename
+            boost::enable_if<
+                traits::enable_equality<Seq1, Seq2>
+              , bool
+            >::type
+        operator==(Seq1 const& a, Seq2 const& b)
+        {
+            return fusion::equal_to(a, b);
+        }
+    }
+    using operators::operator==;
+}}
+namespace boost { namespace fusion {
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    inline bool
+    linear_any(First const&, Last const&, F const&, mpl::true_)
+    {
+        return false;
+    }
+    template <typename First, typename Last, typename F>
+    inline bool
+    linear_any(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        typename result_of::deref<First>::type x = *first;
+        return f(x) ||
+            detail::linear_any(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+    template <typename Sequence, typename F, typename Tag>
+    inline bool
+    any(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_any(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+    template<int N>
+    struct unrolled_any
+    {
+        template <typename It, typename F>
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it))||
+                f(*fusion::advance_c<2>(it)) ||
+                f(*fusion::advance_c<3>(it)) ||
+                detail::unrolled_any<N-4>::call(fusion::advance_c<4>(it), f);
+        }
+    };
+    template<>
+    struct unrolled_any<3>
+    {
+        template <typename It, typename F>
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it)) ||
+                f(*fusion::advance_c<2>(it));
+        }
+    };
+    template<>
+    struct unrolled_any<2>
+    {
+        template <typename It, typename F>
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it));
+        }
+    };
+    template<>
+    struct unrolled_any<1>
+    {
+        template <typename It, typename F>
+        static bool call(It const& it, F f)
+        {
+            return f(*it);
+        }
+    };
+    template<>
+    struct unrolled_any<0>
+    {
+        template <typename It, typename F>
+        static bool call(It const& it, F f)
+        {
+            return false;
+        }
+    };
+    template <typename Sequence, typename F>
+    inline bool
+    any(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_any<result_of::distance<begin, end>::type::value>::call(
+            fusion::begin(seq), f);
+    }
+}}}
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct any
+        {
+            typedef bool type;
+        };
+    }
+    template <typename Sequence, typename F>
+    inline bool
+    any(Sequence const& seq, F f)
+    {
+        return detail::any(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+namespace boost { namespace spirit
+{
+    namespace detail
+    {
+        template <typename Iterator, typename Pred>
+        struct apply_predicate
+          : mpl::apply1<Pred, typename fusion::result_of::value_of<Iterator>::type>
+        {};
+        namespace result_of
+        {
+            template <
+                typename Iterator1, typename Iterator2, typename Last2
+              , typename Pred>
+            struct attribute_next
+            {
+                typedef mpl::and_<
+                    apply_predicate<Iterator1, Pred>
+                  , mpl::not_<fusion::result_of::equal_to<Iterator2, Last2> >
+                > pred;
+                typedef typename
+                    mpl::eval_if<
+                        pred
+                      , fusion::result_of::next<Iterator2>
+                      , mpl::identity<Iterator2>
+                    >::type
+                type;
+                template <typename Iterator>
+                static type
+                call(Iterator const& i, mpl::true_)
+                {
+                    return fusion::next(i);
+                }
+                template <typename Iterator>
+                static type
+                call(Iterator const& i, mpl::false_)
+                {
+                    return i;
+                }
+                template <typename Iterator>
+                static type
+                call(Iterator const& i)
+                {
+                    return call(i, pred());
+                }
+            };
+        }
+        template <
+            typename Pred, typename Iterator1, typename Last2
+          , typename Iterator2>
+        inline typename
+            result_of::attribute_next<Iterator1, Iterator2, Last2, Pred
+        >::type const
+        attribute_next(Iterator2 const& i)
+        {
+            return result_of::attribute_next<
+                Iterator1, Iterator2, Last2, Pred>::call(i);
+        }
+        namespace result_of
+        {
+            template <
+                typename Iterator1, typename Iterator2, typename Last2
+              , typename Pred>
+            struct attribute_value
+            {
+                typedef mpl::and_<
+                    apply_predicate<Iterator1, Pred>
+                  , mpl::not_<fusion::result_of::equal_to<Iterator2, Last2> >
+                > pred;
+                typedef typename
+                    mpl::eval_if<
+                        pred
+                      , fusion::result_of::deref<Iterator2>
+                      , mpl::identity<unused_type const>
+                    >::type
+                type;
+                template <typename Iterator>
+                static type
+                call(Iterator const& i, mpl::true_)
+                {
+                    return fusion::deref(i);
+                }
+                template <typename Iterator>
+                static type
+                call(Iterator const&, mpl::false_)
+                {
+                    return unused;
+                }
+                template <typename Iterator>
+                static type
+                call(Iterator const& i)
+                {
+                    return call(i, pred());
+                }
+            };
+        }
+        template <
+            typename Pred, typename Iterator1, typename Last2
+          , typename Iterator2>
+        inline typename
+            result_of::attribute_value<Iterator1, Iterator2, Last2, Pred
+        >::type
+        attribute_value(Iterator2 const& i)
+        {
+            return result_of::attribute_value<
+                Iterator1, Iterator2, Last2, Pred>::call(i);
+        }
+        template <
+            typename Pred, typename First1, typename Last1, typename First2
+          , typename Last2, typename F>
+        inline bool
+        any_if (First1 const&, First2 const&, Last1 const&, Last2 const&
+          , F const&, mpl::true_)
+        {
+            return false;
+        }
+        template <
+            typename Pred, typename First1, typename Last1, typename First2
+          , typename Last2, typename F>
+        inline bool
+        any_if (First1 const& first1, First2 const& first2, Last1 const& last1
+          , Last2 const& last2, F& f, mpl::false_)
+        {
+            typename result_of::attribute_value<First1, First2, Last2, Pred>::type
+                attribute = attribute_value<Pred, First1, Last2>(first2);
+            return f(*first1, attribute) ||
+                detail::any_if<Pred>(
+                    fusion::next(first1)
+                  , attribute_next<Pred, First1, Last2>(first2)
+                  , last1, last2
+                  , f
+                  , fusion::result_of::equal_to<
+                        typename fusion::result_of::next<First1>::type, Last1>());
+        }
+    }
+    template <typename Pred, typename Sequence1, typename Sequence2, typename F>
+    inline bool
+    any_if(Sequence1 const& seq1, Sequence2& seq2, F f, Pred)
+    {
+        return detail::any_if<Pred>(
+                fusion::begin(seq1), fusion::begin(seq2)
+              , fusion::end(seq1), fusion::end(seq2)
+              , f
+              , fusion::result_of::equal_to<
+                    typename fusion::result_of::begin<Sequence1>::type
+                  , typename fusion::result_of::end<Sequence1>::type>());
+    }
+    template <typename Pred, typename Sequence, typename F>
+    inline bool
+    any_if(Sequence const& seq, unused_type const, F f, Pred)
+    {
+        return fusion::any(seq, f);
+    }
+}}
+namespace boost { namespace spirit { namespace detail
+{
+    template <typename Context>
+    struct what_function
+    {
+        what_function(info& what, Context& context)
+          : what(what), context(context)
+        {
+            what.value = std::list<info>();
+        }
+        template <typename Component>
+        void operator()(Component const& component) const
+        {
+            boost::get<std::list<info> >(what.value).
+                push_back(component.what(context));
+        }
+        info& what;
+        Context& context;
+    private:
+        what_function& operator= (what_function const&);
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    namespace detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_sequence_base_id { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::sequence_base_id>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+    }
+    template <typename Derived, typename Attribute>
+    struct pass_attribute<Derived, Attribute,
+        typename enable_if<detail::has_sequence_base_id<Derived> >::type>
+      : wrap_if_not_tuple<Attribute> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Derived, typename Elements>
+    struct sequence_base
+      : nary_parser<Derived>
+    {
+        typedef Elements elements_type;
+        struct sequence_base_id;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename traits::build_attribute_sequence<
+                Elements, Context, traits::sequence_attribute_transform
+              , Iterator, qi::domain
+            >::type all_attributes;
+            typedef typename
+                traits::build_fusion_vector<all_attributes>::type
+            type_;
+            typedef typename
+                traits::strip_single_element_vector<type_>::type
+            type;
+        };
+        sequence_base(Elements const& elements)
+          : elements(elements) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse_impl(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr_, mpl::false_) const
+        {
+            Iterator iter = first;
+            typedef traits::attribute_not_unused<Context, Iterator> predicate;
+            typedef typename attribute<Context, Iterator>::type_ attr_type_;
+            typename traits::wrap_if_not_tuple<Attribute
+              , typename mpl::and_<
+                    traits::one_element_sequence<attr_type_>
+                  , mpl::not_<traits::one_element_sequence<Attribute> >
+                >::type
+            >::type attr(attr_);
+            if (spirit::any_if(elements, attr
+              , Derived::fail_function(iter, last, context, skipper), predicate()))
+                return false;
+            first = iter;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse_impl(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr_, mpl::true_) const
+        {
+            traits::make_container(attr_);
+            Iterator iter = first;
+            if (fusion::any(elements
+              , detail::make_sequence_pass_container(
+                    Derived::fail_function(iter, last, context, skipper), attr_))
+                )
+                return false;
+            first = iter;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            return parse_impl(first, last, context, skipper, attr
+              , traits::is_container<Attribute>());
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            info result(this->derived().id());
+            fusion::for_each(elements,
+                spirit::detail::what_function<Context>(result, context));
+            return result;
+        }
+        Elements elements;
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    struct clear_mode { enum enum_type
+    {
+        clear_if_enabled,
+        clear_always
+    };
+    };
+    template <typename Iterator>
+    void clear_queue(Iterator&
+      , clear_mode::enum_type = clear_mode::clear_if_enabled)
+    {}
+    template <typename Iterator>
+    void inhibit_clear_queue(Iterator&, bool)
+    {}
+    template <typename Iterator>
+    bool inhibit_clear_queue(Iterator&)
+    {
+        return false;
+    }
+    template <typename Iterator>
+    struct is_multi_pass : mpl::false_ {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <
+        typename Iterator, typename Context
+      , typename Skipper, typename Exception>
+    struct expect_function
+    {
+        typedef Iterator iterator_type;
+        typedef Context context_type;
+        expect_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+          : first(first)
+          , last(last)
+          , context(context)
+          , skipper(skipper)
+          , is_first(true)
+        {
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, Attribute& attr) const
+        {
+            if (!is_first)
+                spirit::traits::clear_queue(first);
+            if (!component.parse(first, last, context, skipper, attr))
+            {
+                if (is_first)
+                {
+                    is_first = false;
+                    return true;
+                }
+                boost::throw_exception(Exception(first, last, component.what(context)));
+            }
+            is_first = false;
+            return false;
+        }
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            if (!is_first)
+                spirit::traits::clear_queue(first);
+            if (!component.parse(first, last, context, skipper, unused))
+            {
+                if (is_first)
+                {
+                    is_first = false;
+                    return true;
+                }
+                boost::throw_exception(Exception(first, last, component.what(context)));
+            }
+            is_first = false;
+            return false;
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+        mutable bool is_first;
+    private:
+        expect_function& operator= (expect_function const&);
+    };
+}}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::greater>
+      : mpl::true_ {};
+    template <>
+    struct flatten_tree<qi::domain, proto::tag::greater>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator>
+    struct expectation_failure : std::runtime_error
+    {
+        expectation_failure(Iterator first, Iterator last, info const& what)
+          : std::runtime_error("boost::spirit::qi::expectation_failure")
+          , first(first), last(last), what_(what)
+        {}
+        ~expectation_failure() throw() {}
+        Iterator first;
+        Iterator last;
+        info what_;
+    };
+    template <typename Elements>
+    struct expect : sequence_base<expect<Elements>, Elements>
+    {
+        friend struct sequence_base<expect<Elements>, Elements>;
+        expect(Elements const& elements)
+          : sequence_base<expect<Elements>, Elements>(elements) {}
+    private:
+        template <typename Iterator, typename Context, typename Skipper>
+        static detail::expect_function<
+            Iterator, Context, Skipper
+          , expectation_failure<Iterator> >
+        fail_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+        {
+            return detail::expect_function<
+                Iterator, Context, Skipper, expectation_failure<Iterator> >
+                (first, last, context, skipper);
+        }
+        std::string id() const { return "expect"; }
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::greater, Elements, Modifiers>
+      : make_nary_composite<Elements, expect>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Elements>
+    struct has_semantic_action<qi::expect<Elements> >
+      : nary_has_semantic_action<Elements> {};
+    template <typename Elements, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::expect<Elements>, Attribute, Context
+          , Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    enum error_handler_result
+    {
+        fail
+      , retry
+      , accept
+      , rethrow
+    };
+    namespace detail
+    {
+        template <typename Iterator, bool active>
+        struct reset_on_exit
+        {
+            reset_on_exit(Iterator&) {}
+        };
+        template <typename Iterator>
+        struct reset_on_exit<Iterator, true>
+        {
+            reset_on_exit(Iterator& it)
+              : it_(it)
+              , inhibit_clear_queue_(spirit::traits::inhibit_clear_queue(it))
+            {
+                spirit::traits::inhibit_clear_queue(it_, true);
+            }
+            ~reset_on_exit()
+            {
+                spirit::traits::inhibit_clear_queue(it_, inhibit_clear_queue_);
+            }
+            Iterator& it_;
+            bool inhibit_clear_queue_;
+        };
+    }
+    template <
+        typename Iterator, typename Context
+      , typename Skipper, typename F, error_handler_result action
+    >
+    struct error_handler
+    {
+        typedef function<
+            bool(Iterator& first, Iterator const& last
+              , Context& context
+              , Skipper const& skipper
+            )>
+        function_type;
+        error_handler(function_type subject, F f)
+          : subject(subject)
+          , f(f)
+        {
+        }
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            typedef qi::detail::reset_on_exit<Iterator
+              , traits::is_multi_pass<Iterator>::value &&
+                  (action == retry || action == fail)> on_exit_type;
+            on_exit_type on_exit(first);
+            for(;;)
+            {
+                try
+                {
+                    Iterator i = first;
+                    bool r = subject(i, last, context, skipper);
+                    if (r)
+                        first = i;
+                    return r;
+                }
+                catch (expectation_failure<Iterator> const& x)
+                {
+                    typedef
+                        fusion::vector<
+                            Iterator&
+                          , Iterator const&
+                          , Iterator const&
+                          , info const&>
+                    params;
+                    error_handler_result r = action;
+                    params args(first, last, x.first, x.what_);
+                    f(args, context, r);
+                    switch (r)
+                    {
+                        case fail:
+                            (static_cast<void> (0))
+                                                                      ;
+                            return false;
+                        case retry:
+                            (static_cast<void> (0))
+                                                                      ;
+                            continue;
+                        case accept: return true;
+                        case rethrow: boost::throw_exception(x);
+                    }
+                }
+            }
+            return false;
+        }
+        function_type subject;
+        F f;
+    };
+    template <
+        error_handler_result action
+      , typename Iterator, typename T0, typename T1, typename T2
+      , typename F>
+    void on_error(rule<Iterator, T0, T1, T2>& r, F f)
+    {
+        typedef rule<Iterator, T0, T1, T2> rule_type;
+        typedef
+            error_handler<
+                Iterator
+              , typename rule_type::context_type
+              , typename rule_type::skipper_type
+              , F
+              , action>
+        error_handler;
+        r.f = error_handler(r.f, f);
+    }
+    template <typename Iterator, typename T0, typename T1
+      , typename T2, typename F>
+    void on_error(rule<Iterator, T0, T1, T2>& r, F f)
+    {
+        on_error<fail>(r, f);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    enum debug_handler_state
+    {
+        pre_parse
+      , successful_parse
+      , failed_parse
+    };
+}}}
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Tag>
+        int get_xalloc_index(Tag* = 0)
+        {
+            static int index = std::ios::xalloc();
+            return index;
+        }
+        template <typename Stream, typename Tag, typename T>
+        struct stream_data
+        {
+            struct arena
+            {
+                ~arena()
+                {
+                    for (
+                        typename std::vector<T*>::iterator i = data.begin()
+                      ; i != data.end()
+                      ; ++i)
+                    {
+                        delete *i;
+                    }
+                }
+                std::vector<T*> data;
+            };
+            static void attach(Stream& stream, T const& data)
+            {
+                static arena ar;
+                ar.data.push_back(new T(data));
+                stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
+            }
+            static T const* get(Stream& stream)
+            {
+                return (T const*)stream.pword(get_xalloc_index<Tag>());
+            }
+        };
+        template <typename Tag, typename Stream>
+        class string_ios_manip
+        {
+        public:
+            typedef std::basic_string< typename Stream::char_type , typename Stream::traits_type > string_type;
+            typedef stream_data<Stream, Tag, string_type> stream_data_t;
+            string_ios_manip(Stream& str_)
+                : stream(str_)
+            {}
+            void
+            set(string_type const& s)
+            {
+                stream_data_t::attach(stream, s);
+            }
+            void
+            print(char const* default_) const
+            {
+                string_type const* p = stream_data_t::get(stream);
+                if (p)
+                    stream << *p;
+                else
+                    stream << default_;
+            }
+            void
+            read(char const* default_) const
+            {
+                string_type const* p = stream_data_t::get(stream);
+                using namespace std;
+                ws(stream);
+                if (p)
+                {
+                    typedef typename string_type::const_iterator iterator;
+                    for (iterator i = p->begin(); i != p->end(); ++i)
+                        check_delim(*i);
+                }
+                else
+                {
+                    while (*default_)
+                        check_delim(*default_++);
+                }
+            }
+        private:
+            template <typename Char>
+            void
+            check_delim(Char c) const
+            {
+                if (!isspace(c))
+                {
+                    if (stream.get() != c)
+                    {
+                        stream.unget();
+                        stream.setstate(std::ios::failbit);
+                    }
+                }
+            }
+            Stream& stream;
+        private:
+            string_ios_manip& operator= (string_ios_manip const&);
+        };
+    }
+    namespace detail { struct tuple_open_tag; template <typename Char, typename Traits = std::char_traits<Char> > struct tuple_open_type { typedef std::basic_string<Char, Traits> string_type; string_type data; tuple_open_type(const string_type& d): data(d) {} }; template <typename Stream, typename Char, typename Traits> Stream& operator>>(Stream& s, const tuple_open_type<Char,Traits>& m) { string_ios_manip<tuple_open_tag, Stream>(s).set(m.data); return s; } template <typename Stream, typename Char, typename Traits> Stream& operator<<(Stream& s, const tuple_open_type<Char,Traits>& m) { string_ios_manip<tuple_open_tag, Stream>(s).set(m.data); return s; } }
+    namespace detail { struct tuple_close_tag; template <typename Char, typename Traits = std::char_traits<Char> > struct tuple_close_type { typedef std::basic_string<Char, Traits> string_type; string_type data; tuple_close_type(const string_type& d): data(d) {} }; template <typename Stream, typename Char, typename Traits> Stream& operator>>(Stream& s, const tuple_close_type<Char,Traits>& m) { string_ios_manip<tuple_close_tag, Stream>(s).set(m.data); return s; } template <typename Stream, typename Char, typename Traits> Stream& operator<<(Stream& s, const tuple_close_type<Char,Traits>& m) { string_ios_manip<tuple_close_tag, Stream>(s).set(m.data); return s; } }
+    namespace detail { struct tuple_delimiter_tag; template <typename Char, typename Traits = std::char_traits<Char> > struct tuple_delimiter_type { typedef std::basic_string<Char, Traits> string_type; string_type data; tuple_delimiter_type(const string_type& d): data(d) {} }; template <typename Stream, typename Char, typename Traits> Stream& operator>>(Stream& s, const tuple_delimiter_type<Char,Traits>& m) { string_ios_manip<tuple_delimiter_tag, Stream>(s).set(m.data); return s; } template <typename Stream, typename Char, typename Traits> Stream& operator<<(Stream& s, const tuple_delimiter_type<Char,Traits>& m) { string_ios_manip<tuple_delimiter_tag, Stream>(s).set(m.data); return s; } }
+    template <typename Char, typename Traits> inline detail::tuple_open_type<Char, Traits> tuple_open(const std::basic_string<Char, Traits>& s) { return detail::tuple_open_type<Char, Traits>(s); } template <typename Char> inline detail::tuple_open_type<Char> tuple_open(Char s[]) { return detail::tuple_open_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_open_type<Char> tuple_open(Char const s[]) { return detail::tuple_open_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_open_type<Char> tuple_open(Char c) { return detail::tuple_open_type<Char>(std::basic_string<Char>(1, c)); }
+    template <typename Char, typename Traits> inline detail::tuple_close_type<Char, Traits> tuple_close(const std::basic_string<Char, Traits>& s) { return detail::tuple_close_type<Char, Traits>(s); } template <typename Char> inline detail::tuple_close_type<Char> tuple_close(Char s[]) { return detail::tuple_close_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_close_type<Char> tuple_close(Char const s[]) { return detail::tuple_close_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_close_type<Char> tuple_close(Char c) { return detail::tuple_close_type<Char>(std::basic_string<Char>(1, c)); }
+    template <typename Char, typename Traits> inline detail::tuple_delimiter_type<Char, Traits> tuple_delimiter(const std::basic_string<Char, Traits>& s) { return detail::tuple_delimiter_type<Char, Traits>(s); } template <typename Char> inline detail::tuple_delimiter_type<Char> tuple_delimiter(Char s[]) { return detail::tuple_delimiter_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_delimiter_type<Char> tuple_delimiter(Char const s[]) { return detail::tuple_delimiter_type<Char>(std::basic_string<Char>(s)); } template <typename Char> inline detail::tuple_delimiter_type<Char> tuple_delimiter(Char c) { return detail::tuple_delimiter_type<Char>(std::basic_string<Char>(1, c)); }
+}}
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Tag>
+    struct delimiter_out
+    {
+        template <typename OS>
+        static void
+        print(OS& os, char const* delim, mpl::false_ = mpl::false_())
+        {
+            detail::string_ios_manip<Tag, OS> manip(os);
+            manip.print(delim);
+        }
+        template <typename OS>
+        static void
+        print(OS&, char const*, mpl::true_)
+        {
+        }
+    };
+    struct print_sequence_loop
+    {
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS&, First const&, Last const&, mpl::true_)
+        {
+        }
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS& os, First const& first, Last const& last, mpl::false_)
+        {
+            result_of::equal_to<
+                typename result_of::next<First>::type
+              , Last
+            >
+            is_last;
+            os << *first;
+            delimiter_out<tuple_delimiter_tag>::print(os, " ", is_last);
+            call(os, fusion::next(first), last, is_last);
+        }
+        template <typename OS, typename First, typename Last>
+        static void
+        call(OS& os, First const& first, Last const& last)
+        {
+            result_of::equal_to<First, Last> eq;
+            call(os, first, last, eq);
+        }
+    };
+    template <typename OS, typename Sequence>
+    inline void
+    print_sequence(OS& os, Sequence const& seq)
+    {
+        delimiter_out<tuple_open_tag>::print(os, "(");
+        print_sequence_loop::call(os, fusion::begin(seq), fusion::end(seq));
+        delimiter_out<tuple_close_tag>::print(os, ")");
+    }
+}}}
+namespace boost { namespace fusion
+{
+    template <typename Sequence>
+    inline std::ostream&
+    out(std::ostream& os, Sequence& seq)
+    {
+        detail::print_sequence(os, seq);
+        return os;
+    }
+    namespace operators
+    {
+        template <typename Sequence>
+        inline typename
+            boost::enable_if<
+               fusion::traits::is_sequence<Sequence>
+              , std::ostream&
+            >::type
+        operator<<(std::ostream& os, Sequence const& seq)
+        {
+            return fusion::out(os, seq);
+        }
+    }
+    using operators::operator<<;
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Iterator, typename Context
+      , typename Skipper, typename F>
+    struct debug_handler
+    {
+        typedef function<
+            bool(Iterator& first, Iterator const& last
+              , Context& context
+              , Skipper const& skipper
+            )>
+        function_type;
+        debug_handler(
+            function_type subject
+          , F f
+          , std::string const& rule_name)
+          : subject(subject)
+          , f(f)
+          , rule_name(rule_name)
+        {
+        }
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            f(first, last, context, pre_parse, rule_name);
+            try
+            {
+                if (subject(first, last, context, skipper))
+                {
+                    f(first, last, context, successful_parse, rule_name);
+                    return true;
+                }
+                f(first, last, context, failed_parse, rule_name);
+            }
+            catch (expectation_failure<Iterator> const& e)
+            {
+                f(first, last, context, failed_parse, rule_name);
+                boost::throw_exception(e);
+            }
+            return false;
+        }
+        function_type subject;
+        F f;
+        std::string rule_name;
+    };
+    template <typename Iterator
+      , typename T1, typename T2, typename T3, typename T4, typename F>
+    void debug(rule<Iterator, T1, T2, T3, T4>& r, F f)
+    {
+        typedef rule<Iterator, T1, T2, T3, T4> rule_type;
+        typedef
+            debug_handler<
+                Iterator
+              , typename rule_type::context_type
+              , typename rule_type::skipper_type
+              , F>
+        debug_handler;
+        r.f = debug_handler(r.f, f, r.name());
+    }
+    struct simple_trace;
+    namespace detail
+    {
+        template<typename T>
+        struct get_simple_trace
+        {
+            typedef simple_trace type;
+        };
+    }
+    template <typename Iterator
+      , typename T1, typename T2, typename T3, typename T4>
+    void debug(rule<Iterator, T1, T2, T3, T4>& r)
+    {
+        typedef rule<Iterator, T1, T2, T3, T4> rule_type;
+        typedef
+            debug_handler<
+                Iterator
+              , typename rule_type::context_type
+              , typename rule_type::skipper_type
+              , simple_trace>
+        debug_handler;
+        typedef typename qi::detail::get_simple_trace<Iterator>::type trace;
+        r.f = debug_handler(r.f, trace(), r.name());
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    namespace detail
+    {
+        template<typename Char>
+        inline void token_printer(std::ostream& o, Char c)
+        {
+            spirit::traits::print_token(o, c);
+        }
+    }
+    struct simple_trace
+    {
+        int& get_indent() const
+        {
+            static int indent = 0;
+            return indent;
+        }
+        void print_indent(int n) const
+        {
+            n *= 2;
+            for (int i = 0; i != n; ++i)
+                std::cerr << ' ';
+        }
+        template <typename Iterator>
+        void print_some(
+            char const* tag
+          , int
+          , Iterator first, Iterator const& last) const
+        {
+            print_indent(get_indent());
+            std::cerr << '<' << tag << '>';
+            int const n = 20;
+            for (int i = 0; first != last && i != n && *first; ++i, ++first)
+                detail::token_printer(std::cerr, *first);
+            std::cerr << "</" << tag << '>' << std::endl;
+        }
+        template <typename Iterator, typename Context, typename State>
+        void operator()(
+            Iterator const& first
+          , Iterator const& last
+          , Context const& context
+          , State state
+          , std::string const& rule_name) const
+        {
+            switch (state)
+            {
+                case pre_parse:
+                    print_indent(get_indent()++);
+                    std::cerr
+                        << '<' << rule_name << '>'
+                        << std::endl;
+                    print_some("try", get_indent(), first, last);
+                    break;
+                case successful_parse:
+                    print_some("success", get_indent(), first, last);
+                    print_indent(get_indent());
+                    std::cerr
+                        << "<attributes>";
+                    traits::print_attribute(
+                        std::cerr,
+                        context.attributes
+                    );
+                    std::cerr
+                        << "</attributes>";
+                    if (!fusion::empty(context.locals))
+                        std::cerr
+                            << "<locals>"
+                            << context.locals
+                            << "</locals>";
+                    std::cerr << std::endl;
+                    print_indent(--get_indent());
+                    std::cerr
+                        << "</" << rule_name << '>'
+                        << std::endl;
+                    break;
+                case failed_parse:
+                    print_indent(get_indent());
+                    std::cerr << "<fail/>" << std::endl;
+                    print_indent(--get_indent());
+                    std::cerr
+                        << "</" << rule_name << '>'
+                        << std::endl;
+                    break;
+            }
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Iterator, typename Context
+      , typename Skipper, typename F
+    >
+    struct success_handler
+    {
+        typedef function<
+            bool(Iterator& first, Iterator const& last
+              , Context& context
+              , Skipper const& skipper
+            )>
+        function_type;
+        success_handler(function_type subject, F f)
+          : subject(subject)
+          , f(f)
+        {
+        }
+        bool operator()(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper) const
+        {
+            Iterator i = first;
+            bool r = subject(i, last, context, skipper);
+            if (r)
+            {
+                typedef
+                    fusion::vector<
+                        Iterator&
+                      , Iterator const&
+                      , Iterator const&>
+                params;
+                skip_over(first, last, skipper);
+                params args(first, last, i);
+                f(args, context);
+                first = i;
+            }
+            return r;
+        }
+        function_type subject;
+        F f;
+    };
+    template <
+        typename Iterator, typename T0, typename T1, typename T2
+      , typename F>
+    void on_success(rule<Iterator, T0, T1, T2>& r, F f)
+    {
+        typedef rule<Iterator, T0, T1, T2> rule_type;
+        typedef
+            success_handler<
+                Iterator
+              , typename rule_type::context_type
+              , typename rule_type::skipper_type
+              , F>
+        success_handler;
+        r.f = success_handler(r.f, f);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Char, typename Iterator, typename Attribute>
+    inline bool string_parse(
+        Char const* str
+      , Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        Iterator i = first;
+        Char ch = *str;
+        for (; !!ch; ++i)
+        {
+            if (i == last || (ch != *i))
+                return false;
+            ch = *++str;
+        }
+        spirit::traits::assign_to(first, i, attr);
+        first = i;
+        return true;
+    }
+    template <typename String, typename Iterator, typename Attribute>
+    inline bool string_parse(
+        String const& str
+      , Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        Iterator i = first;
+        typename String::const_iterator stri = str.begin();
+        typename String::const_iterator str_last = str.end();
+        for (; stri != str_last; ++stri, ++i)
+            if (i == last || (*stri != *i))
+                return false;
+        spirit::traits::assign_to(first, i, attr);
+        first = i;
+        return true;
+    }
+    template <typename Char, typename Iterator, typename Attribute>
+    inline bool string_parse(
+        Char const* uc_i, Char const* lc_i
+      , Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        Iterator i = first;
+        for (; *uc_i && *lc_i; ++uc_i, ++lc_i, ++i)
+            if (i == last || ((*uc_i != *i) && (*lc_i != *i)))
+                return false;
+        spirit::traits::assign_to(first, i, attr);
+        first = i;
+        return true;
+    }
+    template <typename String, typename Iterator, typename Attribute>
+    inline bool string_parse(
+        String const& ucstr, String const& lcstr
+      , Iterator& first, Iterator const& last, Attribute& attr)
+    {
+        typename String::const_iterator uc_i = ucstr.begin();
+        typename String::const_iterator uc_last = ucstr.end();
+        typename String::const_iterator lc_i = lcstr.begin();
+        Iterator i = first;
+        for (; uc_i != uc_last; ++uc_i, ++lc_i, ++i)
+            if (i == last || ((*uc_i != *i) && (*lc_i != *i)))
+                return false;
+        spirit::traits::assign_to(first, i, attr);
+        first = i;
+        return true;
+    }
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename T = bool>
+    struct bool_policies
+    {
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (detail::string_parse("true", first, last, unused))
+            {
+                spirit::traits::assign_to(T(true), attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (detail::string_parse("false", first, last, unused))
+            {
+                spirit::traits::assign_to(T(false), attr);
+                return true;
+            }
+            return false;
+        }
+    };
+    template <typename T = bool>
+    struct no_case_bool_policies
+    {
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (detail::string_parse("true", "TRUE", first, last, unused))
+            {
+                spirit::traits::assign_to(T(true), attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (detail::string_parse("false", "FALSE", first, last, unused))
+            {
+                spirit::traits::assign_to(T(false), attr);
+                return true;
+            }
+            return false;
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    namespace qi
+    {
+        template <typename T>
+        struct bool_policies;
+        template <typename T, typename BoolPolicies = bool_policies<T> >
+        struct bool_parser
+          : spirit::terminal<tag::stateful_tag<BoolPolicies, tag::bool_, T> >
+        {
+            typedef tag::stateful_tag<BoolPolicies, tag::bool_, T> tag_type;
+            bool_parser() {}
+            bool_parser(BoolPolicies const& data)
+              : spirit::terminal<tag_type>(data) {}
+        };
+    }
+    template <>
+    struct use_terminal<qi::domain, tag::bool_>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::true_>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::false_>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, bool> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::bool_, fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::bool_, 1>
+      : mpl::true_ {};
+    template <typename T, typename BoolPolicies>
+    struct use_terminal<qi::domain
+        , tag::stateful_tag<BoolPolicies, tag::bool_, T> >
+      : mpl::true_ {};
+    template <typename T, typename BoolPolicies, typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::stateful_tag<BoolPolicies, tag::bool_, T>
+        , fusion::vector1<A0> > >
+      : mpl::true_ {};
+    template <typename T, typename BoolPolicies>
+    struct use_lazy_terminal<
+        qi::domain
+      , tag::stateful_tag<BoolPolicies, tag::bool_, T>
+      , 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::bool_;
+    using spirit::true_;
+    using spirit::false_;
+    using spirit::lit;
+    using spirit::bool_type;
+    using spirit::true_type;
+    using spirit::false_type;
+    using spirit::lit_type;
+    namespace detail
+    {
+        template <typename T, typename BoolPolicies>
+        struct bool_impl
+        {
+            template <typename Iterator, typename Attribute>
+            static bool parse(Iterator& first, Iterator const& last
+              , Attribute& attr, BoolPolicies const& p, bool allow_true = true
+              , bool disallow_false = false)
+            {
+                if (first == last)
+                    return false;
+                return (allow_true && p.parse_true(first, last, attr)) ||
+                       (!disallow_false && p.parse_false(first, last, attr));
+            }
+        };
+    }
+    template <typename T, typename BoolPolicies = bool_policies<T> >
+    struct any_bool_parser
+      : primitive_parser<any_bool_parser<T, BoolPolicies> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::bool_impl<T, BoolPolicies> extract;
+            qi::skip_over(first, last, skipper);
+            return extract::parse(first, last, attr, BoolPolicies());
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("boolean");
+        }
+    };
+    template <typename T, typename BoolPolicies = bool_policies<T>
+            , bool no_attribute = true>
+    struct literal_bool_parser
+      : primitive_parser<literal_bool_parser<T, BoolPolicies, no_attribute> >
+    {
+        template <typename Value>
+        literal_bool_parser(Value const& n) : n_(n) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+          : mpl::if_c<no_attribute, unused_type, T>
+        {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::bool_impl<T, BoolPolicies> extract;
+            qi::skip_over(first, last, skipper);
+            return extract::parse(first, last, attr, BoolPolicies(), n_, n_);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("boolean");
+        }
+        T n_;
+    };
+    template <typename T, typename Modifiers
+            , typename Policies = bool_policies<T> >
+    struct make_bool
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> >
+            no_case;
+        typedef typename mpl::if_<
+            mpl::and_<
+                no_case
+              , is_same<bool_policies<T>, Policies>
+            >
+          , any_bool_parser<T, no_case_bool_policies<T> >
+          , any_bool_parser<T, Policies> >::type
+        result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename T, typename Modifiers
+            , typename Policies = bool_policies<T> >
+    struct make_direct_bool
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> >
+            no_case;
+        typedef typename mpl::if_<
+            mpl::and_<
+                no_case
+              , is_same<bool_policies<T>, Policies>
+            >
+          , literal_bool_parser<T, no_case_bool_policies<T>, false>
+          , literal_bool_parser<T, Policies, false> >::type
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename T, typename Modifiers, bool b
+            , typename Policies = bool_policies<T> >
+    struct make_predefined_direct_bool
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> >
+            no_case;
+        typedef typename mpl::if_<
+            mpl::and_<
+                no_case
+              , is_same<bool_policies<T>, Policies>
+            >
+          , literal_bool_parser<T, no_case_bool_policies<T>, false>
+          , literal_bool_parser<T, Policies, false> >::type
+        result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type(b);
+        }
+    };
+    template <typename T, typename Modifiers
+            , typename Policies = bool_policies<T> >
+    struct make_literal_bool
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> >
+            no_case;
+        typedef typename mpl::if_<
+            mpl::and_<
+                no_case
+              , is_same<bool_policies<T>, Policies>
+            >
+          , literal_bool_parser<T, no_case_bool_policies<T> >
+          , literal_bool_parser<T, Policies> >::type
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, bool> >::type>
+      : make_literal_bool<bool, Modifiers> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::false_, Modifiers>
+      : make_predefined_direct_bool<bool, Modifiers, false>
+    {};
+    template <typename Modifiers>
+    struct make_primitive<tag::true_, Modifiers>
+      : make_predefined_direct_bool<bool, Modifiers, true>
+    {};
+    template <typename T, typename Policies, typename Modifiers>
+    struct make_primitive<
+        tag::stateful_tag<Policies, tag::bool_, T>, Modifiers>
+      : make_bool<T, Modifiers, Policies> {};
+    template <typename T, typename Policies, typename A0, typename Modifiers>
+    struct make_primitive<
+        terminal_ex<tag::stateful_tag<Policies, tag::bool_, T>
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_bool<T, Modifiers, Policies> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::bool_, Modifiers>
+      : make_bool<bool, Modifiers> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::bool_
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_bool<bool, Modifiers> {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename T, unsigned Radix>
+    struct digits_traits;
+        template <typename T> struct digits_traits<T, 2> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 1000000); };
+        template <typename T> struct digits_traits<T, 3> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 1584960); };
+        template <typename T> struct digits_traits<T, 4> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 2000000); };
+        template <typename T> struct digits_traits<T, 5> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 2321920); };
+        template <typename T> struct digits_traits<T, 6> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 2584960); };
+        template <typename T> struct digits_traits<T, 7> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 2807350); };
+        template <typename T> struct digits_traits<T, 8> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3000000); };
+        template <typename T> struct digits_traits<T, 9> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3169920); };
+        template <typename T> struct digits_traits<T, 10> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3321920); };
+        template <typename T> struct digits_traits<T, 11> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3459430); };
+        template <typename T> struct digits_traits<T, 12> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3584960); };
+        template <typename T> struct digits_traits<T, 13> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3700430); };
+        template <typename T> struct digits_traits<T, 14> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3807350); };
+        template <typename T> struct digits_traits<T, 15> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 3906890); };
+        template <typename T> struct digits_traits<T, 16> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4000000); };
+        template <typename T> struct digits_traits<T, 17> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4087460); };
+        template <typename T> struct digits_traits<T, 18> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4169920); };
+        template <typename T> struct digits_traits<T, 19> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4247920); };
+        template <typename T> struct digits_traits<T, 20> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4321920); };
+        template <typename T> struct digits_traits<T, 21> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4392310); };
+        template <typename T> struct digits_traits<T, 22> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4459430); };
+        template <typename T> struct digits_traits<T, 23> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4523560); };
+        template <typename T> struct digits_traits<T, 24> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4584960); };
+        template <typename T> struct digits_traits<T, 25> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4643850); };
+        template <typename T> struct digits_traits<T, 26> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4700430); };
+        template <typename T> struct digits_traits<T, 27> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4754880); };
+        template <typename T> struct digits_traits<T, 28> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4807350); };
+        template <typename T> struct digits_traits<T, 29> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4857980); };
+        template <typename T> struct digits_traits<T, 30> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4906890); };
+        template <typename T> struct digits_traits<T, 31> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 4954190); };
+        template <typename T> struct digits_traits<T, 32> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 5000000); };
+        template <typename T> struct digits_traits<T, 33> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 5044390); };
+        template <typename T> struct digits_traits<T, 34> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 5087460); };
+        template <typename T> struct digits_traits<T, 35> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 5129280); };
+        template <typename T> struct digits_traits<T, 36> { typedef std::numeric_limits<T> numeric_limits_type; static const int value = static_cast<int>( (numeric_limits_type::digits * 1000000) / 5169925); };
+    template <unsigned Radix>
+    struct radix_traits
+    {
+        template <typename Char>
+        inline static bool is_valid(Char ch)
+        {
+            if (Radix <= 10)
+                return (ch >= '0' && ch <= static_cast<Char>('0' + Radix -1));
+            return (ch >= '0' && ch <= '9')
+                || (ch >= 'a' && ch <= static_cast<Char>('a' + Radix -10 -1))
+                || (ch >= 'A' && ch <= static_cast<Char>('A' + Radix -10 -1));
+        }
+        template <typename Char>
+        inline static unsigned digit(Char ch)
+        {
+            if (Radix <= 10 || (ch >= '0' && ch <= '9'))
+                return ch - '0';
+            return spirit::char_encoding::ascii::tolower(ch) - 'a' + 10;
+        }
+    };
+    template <unsigned Radix>
+    struct positive_accumulator
+    {
+        template <typename T, typename Char>
+        inline static void add(T& n, Char ch, mpl::false_)
+        {
+            const int digit = radix_traits<Radix>::digit(ch);
+            n = n * T(Radix) + T(digit);
+        }
+        template <typename T, typename Char>
+        inline static bool add(T& n, Char ch, mpl::true_)
+        {
+            static T const max = (std::numeric_limits<T>::max)();
+            static T const val = max / Radix;
+            if (n > val)
+                return false;
+            n *= Radix;
+            const int digit = radix_traits<Radix>::digit(ch);
+            if (n > max - digit)
+                return false;
+            n += static_cast<T>(digit);
+            return true;
+        }
+    };
+    template <unsigned Radix>
+    struct negative_accumulator
+    {
+        template <typename T, typename Char>
+        inline static void add(T& n, Char ch, mpl::false_)
+        {
+            const int digit = radix_traits<Radix>::digit(ch);
+            n = n * T(Radix) - T(digit);
+        }
+        template <typename T, typename Char>
+        inline static bool add(T& n, Char ch, mpl::true_)
+        {
+            static T const min = (std::numeric_limits<T>::min)();
+            static T const val = (min + 1) / T(Radix);
+            if (n < val)
+                return false;
+            n *= Radix;
+            int const digit = radix_traits<Radix>::digit(ch);
+            if (n < min + digit)
+                return false;
+            n -= static_cast<T>(digit);
+            return true;
+        }
+    };
+    template <unsigned Radix, typename Accumulator, int MaxDigits>
+    struct int_extractor
+    {
+        template <typename Char, typename T>
+        inline static bool
+        call(Char ch, std::size_t count, T& n, mpl::true_)
+        {
+            static std::size_t const
+                overflow_free = digits_traits<T, Radix>::value - 1;
+            if (count < overflow_free)
+            {
+                Accumulator::add(n, ch, mpl::false_());
+            }
+            else
+            {
+                if (!Accumulator::add(n, ch, mpl::true_()))
+                    return false;
+            }
+            return true;
+        }
+        template <typename Char, typename T>
+        inline static bool
+        call(Char ch, std::size_t , T& n, mpl::false_)
+        {
+            Accumulator::add(n, ch, mpl::false_());
+            return true;
+        }
+        template <typename Char>
+        inline static bool
+        call(Char , std::size_t , unused_type, mpl::false_)
+        {
+            return true;
+        }
+        template <typename Char, typename T>
+        inline static bool
+        call(Char ch, std::size_t count, T& n)
+        {
+            return call(ch, count, n
+              , mpl::bool_<
+                    ( (MaxDigits < 0)
+                    || (MaxDigits > digits_traits<T, Radix>::value)
+                    )
+                  && std::numeric_limits<T>::is_modulo
+                >()
+            );
+        }
+    };
+    template <int MaxDigits>
+    struct check_max_digits
+    {
+        inline static bool
+        call(std::size_t count)
+        {
+            return count < MaxDigits;
+        }
+    };
+    template <>
+    struct check_max_digits<-1>
+    {
+        inline static bool
+        call(std::size_t )
+        {
+            return true;
+        }
+    };
+    template <
+        typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+      , typename Accumulator = positive_accumulator<Radix>
+      , bool Accumulate = false
+    >
+    struct extract_int
+    {
+        template <typename Iterator, typename Attribute>
+        inline static bool
+        parse_main(
+            Iterator& first
+          , Iterator const& last
+          , Attribute& attr)
+        {
+            typedef radix_traits<Radix> radix_check;
+            typedef int_extractor<Radix, Accumulator, MaxDigits> extractor;
+            typedef typename
+                boost::detail::iterator_traits<Iterator>::value_type
+            char_type;
+            Iterator it = first;
+            std::size_t leading_zeros = 0;
+            if (!Accumulate)
+            {
+                while (it != last && *it == '0' && leading_zeros < MaxDigits)
+                {
+                    ++it;
+                    ++leading_zeros;
+                }
+            }
+            typedef typename
+                traits::attribute_type<Attribute>::type
+            attribute_type;
+            attribute_type val = Accumulate ? attr : attribute_type(0);
+            std::size_t count = 0;
+            char_type ch;
+            while (true)
+            {
+ if (!check_max_digits<MaxDigits>::call(count + leading_zeros) || it == last) break; ch = *it; if (!radix_check::is_valid(ch) || !extractor::call(ch, count, val)) break; ++it; ++count; if (!check_max_digits<MaxDigits>::call(count + leading_zeros) || it == last) break; ch = *it; if (!radix_check::is_valid(ch) || !extractor::call(ch, count, val)) break; ++it; ++count; if (!check_max_digits<MaxDigits>::call(count + leading_zeros) || it == last) break; ch = *it; if (!radix_check::is_valid(ch) || !extractor::call(ch, count, val)) break; ++it; ++count;
+            }
+            if (count + leading_zeros >= MinDigits)
+            {
+                traits::assign_to(val, attr);
+                first = it;
+                return true;
+            }
+            return false;
+        }
+        template <typename Iterator>
+        inline static bool
+        parse(
+            Iterator& first
+          , Iterator const& last
+          , unused_type)
+        {
+            T n = 0;
+            return parse_main(first, last, n);
+        }
+        template <typename Iterator, typename Attribute>
+        inline static bool
+        parse(
+            Iterator& first
+          , Iterator const& last
+          , Attribute& attr)
+        {
+            return parse_main(first, last, attr);
+        }
+    };
+    template <typename T, unsigned Radix, typename Accumulator, bool Accumulate>
+    struct extract_int<T, Radix, 1, -1, Accumulator, Accumulate>
+    {
+        template <typename Iterator, typename Attribute>
+        inline static bool
+        parse_main(
+            Iterator& first
+          , Iterator const& last
+          , Attribute& attr)
+        {
+            typedef radix_traits<Radix> radix_check;
+            typedef int_extractor<Radix, Accumulator, -1> extractor;
+            typedef typename
+                boost::detail::iterator_traits<Iterator>::value_type
+            char_type;
+            Iterator it = first;
+            std::size_t count = 0;
+            if (!Accumulate)
+            {
+                while (it != last && *it == '0')
+                {
+                    ++it;
+                    ++count;
+                }
+                if (it == last)
+                {
+                    if (count == 0)
+                        return false;
+                    traits::assign_to(0, attr);
+                    first = it;
+                    return true;
+                }
+            }
+            typedef typename
+                traits::attribute_type<Attribute>::type
+            attribute_type;
+            attribute_type val = Accumulate ? attr : attribute_type(0);
+            char_type ch = *it;
+            if (!radix_check::is_valid(ch) || !extractor::call(ch, 0, val))
+            {
+                if (count == 0)
+                    return false;
+                traits::assign_to(val, attr);
+                first = it;
+                return true;
+            }
+            count = 0;
+            ++it;
+            while (true)
+            {
+ if (it == last) break; ch = *it; if (!radix_check::is_valid(ch)) break; if (!extractor::call(ch, count, val)) return false; ++it; ++count; if (it == last) break; ch = *it; if (!radix_check::is_valid(ch)) break; if (!extractor::call(ch, count, val)) return false; ++it; ++count; if (it == last) break; ch = *it; if (!radix_check::is_valid(ch)) break; if (!extractor::call(ch, count, val)) return false; ++it; ++count;
+            }
+            traits::assign_to(val, attr);
+            first = it;
+            return true;
+        }
+        template <typename Iterator>
+        inline static bool
+        parse(
+            Iterator& first
+          , Iterator const& last
+          , unused_type)
+        {
+            T n = 0;
+            return parse_main(first, last, n);
+        }
+        template <typename Iterator, typename Attribute>
+        inline static bool
+        parse(
+            Iterator& first
+          , Iterator const& last
+          , Attribute& attr)
+        {
+            return parse_main(first, last, attr);
+        }
+    };
+    template <typename T,
+        bool force_unsigned
+            = mpl::and_<is_integral<T>, is_signed<T> >::value>
+    struct cast_unsigned;
+    template <typename T>
+    struct cast_unsigned<T, true>
+    {
+        typedef typename make_unsigned<T>::type unsigned_type;
+        typedef typename make_unsigned<T>::type& unsigned_type_ref;
+        inline static unsigned_type_ref call(T& n)
+        {
+            return unsigned_type_ref(n);
+        }
+    };
+    template <typename T>
+    struct cast_unsigned<T, false>
+    {
+        inline static T& call(T& n)
+        {
+            return n;
+        }
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator>
+    inline bool
+    extract_sign(Iterator& first, Iterator const& last)
+    {
+        (void)last;
+        (static_cast<void> (0));
+        bool neg = *first == '-';
+        if (neg || (*first == '+'))
+        {
+            ++first;
+            return neg;
+        }
+        return false;
+    }
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+      , bool Accumulate = false>
+    struct extract_uint
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix53
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg53
+        ; enum { mpl_assertion_in_line_53 = sizeof( boost::mpl::assertion_failed<(Radix >= 2 && Radix <= 36)>( mpl_assert_arg53::assert_arg() ) ) }
+                                    ;
+        template <typename Iterator>
+        inline static bool call(Iterator& first, Iterator const& last, T& attr)
+        {
+            if (first == last)
+                return false;
+            typedef detail::extract_int<
+                T
+              , Radix
+              , MinDigits
+              , MaxDigits
+              , detail::positive_accumulator<Radix>
+              , Accumulate>
+            extract_type;
+            Iterator save = first;
+            if (!extract_type::parse(first, last,
+                detail::cast_unsigned<T>::call(attr)))
+            {
+                first = save;
+                return false;
+            }
+            return true;
+        }
+        template <typename Iterator, typename Attribute>
+        inline static bool call(Iterator& first, Iterator const& last, Attribute& attr_)
+        {
+            T attr;
+            if (call(first, last, attr))
+            {
+                traits::assign_to(attr, attr_);
+                return true;
+            }
+            return false;
+        }
+    };
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits>
+    struct extract_int
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix103
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg103
+        ; enum { mpl_assertion_in_line_103 = sizeof( boost::mpl::assertion_failed<(Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16)>( mpl_assert_arg103::assert_arg() ) ) }
+                                    ;
+        template <typename Iterator>
+        inline static bool call(Iterator& first, Iterator const& last, T& attr)
+        {
+            if (first == last)
+                return false;
+            typedef detail::extract_int<
+                T, Radix, MinDigits, MaxDigits>
+            extract_pos_type;
+            typedef detail::extract_int<
+                T, Radix, MinDigits, MaxDigits, detail::negative_accumulator<Radix> >
+            extract_neg_type;
+            Iterator save = first;
+            bool hit = extract_sign(first, last);
+            if (hit)
+                hit = extract_neg_type::parse(first, last, attr);
+            else
+                hit = extract_pos_type::parse(first, last, attr);
+            if (!hit)
+            {
+                first = save;
+                return false;
+            }
+            return true;
+        }
+        template <typename Iterator, typename Attribute>
+        inline static bool call(Iterator& first, Iterator const& last, Attribute& attr_)
+        {
+            T attr;
+            if (call(first, last, attr))
+            {
+                traits::assign_to(attr, attr_);
+                return true;
+            }
+            return false;
+        }
+    };
+}}}
+namespace boost { namespace spirit
+{
+    namespace tag
+    {
+        template <typename T, unsigned Radix, unsigned MinDigits
+                , int MaxDigits>
+        struct int_parser {};
+    }
+    namespace qi
+    {
+        template <typename T = int, unsigned Radix = 10, unsigned MinDigits = 1
+                , int MaxDigits = -1>
+        struct int_parser
+          : spirit::terminal<tag::int_parser<T, Radix, MinDigits, MaxDigits> >
+        {};
+    }
+    template <>
+    struct use_terminal<qi::domain, tag::short_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, signed short> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::short_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::short_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::int_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, signed> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::int_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::int_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::long_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, signed long> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::long_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::long_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::long_long> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, boost::long_long_type> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::long_long, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::long_long, 1> : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits>
+    struct use_terminal<qi::domain
+        , tag::int_parser<T, Radix, MinDigits, MaxDigits> >
+      : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits, typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::int_parser<T, Radix, MinDigits, MaxDigits>
+                  , fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits>
+    struct use_lazy_terminal<qi::domain
+      , tag::int_parser<T, Radix, MinDigits, MaxDigits>, 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::short_;
+    using spirit::int_;
+    using spirit::long_;
+    using spirit::long_long;
+    using spirit::lit;
+    using spirit::short_type;
+    using spirit::int_type;
+    using spirit::long_type;
+    using spirit::lit_type;
+    using spirit::long_long_type;
+    using spirit::lit_type;
+    template <
+        typename T
+      , unsigned Radix = 10
+      , unsigned MinDigits = 1
+      , int MaxDigits = -1>
+    struct any_int_parser
+      : primitive_parser<any_int_parser<T, Radix, MinDigits, MaxDigits> >
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix189
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg189
+        ; enum { mpl_assertion_in_line_189 = sizeof( boost::mpl::assertion_failed<(Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16)>( mpl_assert_arg189::assert_arg() ) ) }
+                                    ;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef extract_int<T, Radix, MinDigits, MaxDigits> extract;
+            qi::skip_over(first, last, skipper);
+            return extract::call(first, last, attr);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("integer");
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1, bool no_attribute = true>
+    struct literal_int_parser
+      : primitive_parser<literal_int_parser<T, Radix, MinDigits, MaxDigits
+        , no_attribute> >
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix225
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg225
+        ; enum { mpl_assertion_in_line_225 = sizeof( boost::mpl::assertion_failed<(Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16)>( mpl_assert_arg225::assert_arg() ) ) }
+                                    ;
+        template <typename Value>
+        literal_int_parser(Value const& n) : n_(n) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+          : mpl::if_c<no_attribute, unused_type, T>
+        {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef extract_int<T, Radix, MinDigits, MaxDigits> extract;
+            qi::skip_over(first, last, skipper);
+            Iterator save = first;
+            T attr_;
+            if (extract::call(first, last, attr_) && (attr_ == n_))
+            {
+                traits::assign_to(attr_, attr);
+                return true;
+            }
+            first = save;
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("integer");
+        }
+        T n_;
+    };
+    template <
+        typename T
+      , unsigned Radix = 10
+      , unsigned MinDigits = 1
+      , int MaxDigits = -1>
+    struct make_int
+    {
+        typedef any_int_parser<T, Radix, MinDigits, MaxDigits> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct make_direct_int
+    {
+        typedef literal_int_parser<T, Radix, MinDigits, MaxDigits, false>
+            result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct make_literal_int
+    {
+        typedef literal_int_parser<T, Radix, MinDigits, MaxDigits> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, signed short> >::type>
+      : make_literal_int<signed short> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, signed> >::type>
+      : make_literal_int<signed> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, signed long> >::type>
+      : make_literal_int<signed long> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, boost::long_long_type> >::type>
+      : make_literal_int<boost::long_long_type> {};
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+            , typename Modifiers>
+    struct make_primitive<
+        tag::int_parser<T, Radix, MinDigits, MaxDigits>
+      , Modifiers>
+      : make_int<T, Radix, MinDigits, MaxDigits> {};
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+            , typename A0, typename Modifiers>
+    struct make_primitive<
+        terminal_ex<tag::int_parser<T, Radix, MinDigits, MaxDigits>
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_int<T, Radix, MinDigits, MaxDigits> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::short_, Modifiers>
+      : make_int<short> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::short_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_int<short> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::int_, Modifiers>
+      : make_int<int> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::int_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_int<int> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::long_, Modifiers>
+      : make_int<long> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::long_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_int<long> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::long_long, Modifiers>
+      : make_int<boost::long_long_type> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::long_long
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_int<boost::long_long_type> {};
+}}}
+namespace boost { namespace spirit
+{
+    namespace tag
+    {
+        template <typename T, unsigned Radix, unsigned MinDigits
+                , int MaxDigits>
+        struct uint_parser
+        {
+        };
+    }
+    namespace qi
+    {
+        template <typename T = int, unsigned Radix = 10, unsigned MinDigits = 1
+                , int MaxDigits = -1>
+        struct uint_parser
+          : spirit::terminal<tag::uint_parser<T, Radix, MinDigits, MaxDigits> >
+        {};
+    }
+    template <>
+    struct use_terminal<qi::domain, tag::ushort_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, unsigned short> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::ushort_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::ushort_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::uint_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, unsigned> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::uint_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::uint_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::ulong_> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, unsigned long> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::ulong_, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::ulong_, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::ulong_long> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, boost::ulong_long_type> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::ulong_long, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::ulong_long, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::bin> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::bin, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::bin, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::oct> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::oct, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::oct, 1> : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::hex> : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::hex, fusion::vector1<A0> > >
+      : is_arithmetic<A0> {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::hex, 1> : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits>
+    struct use_terminal<qi::domain
+        , tag::uint_parser<T, Radix, MinDigits, MaxDigits> >
+      : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits, typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::uint_parser<T, Radix, MinDigits, MaxDigits>
+                  , fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <typename T, unsigned Radix, unsigned MinDigits
+            , int MaxDigits>
+    struct use_lazy_terminal<qi::domain
+      , tag::uint_parser<T, Radix, MinDigits, MaxDigits>, 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::bin;
+    using spirit::oct;
+    using spirit::hex;
+    using spirit::ushort_;
+    using spirit::uint_;
+    using spirit::ulong_;
+    using spirit::ulong_long;
+    using spirit::lit;
+    using spirit::bin_type;
+    using spirit::oct_type;
+    using spirit::hex_type;
+    using spirit::ushort_type;
+    using spirit::uint_type;
+    using spirit::ulong_type;
+    using spirit::ulong_long_type;
+    using spirit::lit_type;
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct any_uint_parser
+      : primitive_parser<any_uint_parser<T, Radix, MinDigits, MaxDigits> >
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix226
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg226
+        ; enum { mpl_assertion_in_line_226 = sizeof( boost::mpl::assertion_failed<(Radix >= 2 && Radix <= 36)>( mpl_assert_arg226::assert_arg() ) ) }
+                                    ;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef extract_uint<T, Radix, MinDigits, MaxDigits> extract;
+            qi::skip_over(first, last, skipper);
+            return extract::call(first, last, attr);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("unsigned-integer");
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1, bool no_attribute = true>
+    struct literal_uint_parser
+      : primitive_parser<literal_uint_parser<T, Radix, MinDigits, MaxDigits
+        , no_attribute> >
+    {
+        struct not_supported_radix; typedef struct
+ not_supported_radix262
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (not_supported_radix::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg262
+        ; enum { mpl_assertion_in_line_262 = sizeof( boost::mpl::assertion_failed<(Radix == 2 || Radix == 8 || Radix == 10 || Radix == 16)>( mpl_assert_arg262::assert_arg() ) ) }
+                                    ;
+        template <typename Value>
+        literal_uint_parser(Value const& n) : n_(n) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+          : mpl::if_c<no_attribute, unused_type, T>
+        {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef extract_uint<T, Radix, MinDigits, MaxDigits> extract;
+            qi::skip_over(first, last, skipper);
+            Iterator save = first;
+            T attr_;
+            if (extract::call(first, last, attr_) && (attr_ == n_))
+            {
+                traits::assign_to(attr_, attr);
+                return true;
+            }
+            first = save;
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("unsigned-integer");
+        }
+        T n_;
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct make_uint
+    {
+        typedef any_uint_parser<T, Radix, MinDigits, MaxDigits> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct make_direct_uint
+    {
+        typedef literal_uint_parser<T, Radix, MinDigits, MaxDigits, false>
+            result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename T, unsigned Radix = 10, unsigned MinDigits = 1
+            , int MaxDigits = -1>
+    struct make_literal_uint
+    {
+        typedef literal_uint_parser<T, Radix, MinDigits, MaxDigits> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, unsigned short> >::type>
+      : make_literal_uint<unsigned short> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, unsigned> >::type>
+      : make_literal_uint<unsigned> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, unsigned long> >::type>
+      : make_literal_uint<unsigned long> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, boost::ulong_long_type> >::type>
+      : make_literal_uint<boost::ulong_long_type> {};
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+            , typename Modifiers>
+    struct make_primitive<
+        tag::uint_parser<T, Radix, MinDigits, MaxDigits>
+      , Modifiers>
+      : make_uint<T, Radix, MinDigits, MaxDigits> {};
+    template <typename T, unsigned Radix, unsigned MinDigits, int MaxDigits
+            , typename A0, typename Modifiers>
+    struct make_primitive<
+        terminal_ex<tag::uint_parser<T, Radix, MinDigits, MaxDigits>
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_uint<T, Radix, MinDigits, MaxDigits> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::bin, Modifiers>
+      : make_uint<unsigned, 2> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::bin
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned, 2> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::oct, Modifiers>
+      : make_uint<unsigned, 8> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::oct
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned, 8> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::hex, Modifiers>
+      : make_uint<unsigned, 16> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::hex
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned, 16> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::ushort_, Modifiers>
+      : make_uint<unsigned short> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::ushort_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned short> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::uint_, Modifiers>
+      : make_uint<unsigned> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::uint_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::ulong_, Modifiers>
+      : make_uint<unsigned long> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::ulong_
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<unsigned long> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::ulong_long, Modifiers>
+      : make_uint<boost::ulong_long_type> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::ulong_long
+      , fusion::vector1<A0> > , Modifiers>
+      : make_direct_uint<boost::ulong_long_type> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename T>
+    struct ureal_policies
+    {
+        static bool const allow_leading_dot = true;
+        static bool const allow_trailing_dot = true;
+        static bool const expect_dot = false;
+        template <typename Iterator>
+        static bool
+        parse_sign(Iterator& , Iterator const& )
+        {
+            return false;
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_n(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            return extract_uint<T, 10, 1, -1>::call(first, last, attr);
+        }
+        template <typename Iterator>
+        static bool
+        parse_dot(Iterator& first, Iterator const& last)
+        {
+            if (first == last || *first != '.')
+                return false;
+            ++first;
+            return true;
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            return extract_uint<T, 10, 1, -1, true>::call(first, last, attr);
+        }
+        template <typename Iterator>
+        static bool
+        parse_exp(Iterator& first, Iterator const& last)
+        {
+            if (first == last || (*first != 'e' && *first != 'E'))
+                return false;
+            ++first;
+            return true;
+        }
+        template <typename Iterator>
+        static bool
+        parse_exp_n(Iterator& first, Iterator const& last, int& attr)
+        {
+            return extract_int<int, 10, 1, -1>::call(first, last, attr);
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_nan(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (first == last)
+                return false;
+            if (*first != 'n' && *first != 'N')
+                return false;
+            if (detail::string_parse("nan", "NAN", first, last, unused))
+            {
+                if (*first == '(')
+                {
+                    Iterator i = first;
+                    while (++i != last && *i != ')')
+                        ;
+                    if (i == last)
+                        return false;
+                    first = ++i;
+                }
+                attr = std::numeric_limits<T>::quiet_NaN();
+                return true;
+            }
+            return false;
+        }
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse_inf(Iterator& first, Iterator const& last, Attribute& attr)
+        {
+            if (first == last)
+                return false;
+            if (*first != 'i' && *first != 'I')
+                return false;
+            if (detail::string_parse("inf", "INF", first, last, unused))
+            {
+                detail::string_parse("inity", "INITY", first, last, unused);
+                attr = std::numeric_limits<T>::infinity();
+                return true;
+            }
+            return false;
+        }
+    };
+    template <typename T>
+    struct real_policies : ureal_policies<T>
+    {
+        template <typename Iterator>
+        static bool
+        parse_sign(Iterator& first, Iterator const& last)
+        {
+            return extract_sign(first, last);
+        }
+    };
+    template <typename T>
+    struct strict_ureal_policies : ureal_policies<T>
+    {
+        static bool const expect_dot = true;
+    };
+    template <typename T>
+    struct strict_real_policies : real_policies<T>
+    {
+        static bool const expect_dot = true;
+    };
+}}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  inline double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+  inline float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+  inline long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    abs(_Tp __x)
+    { return __builtin_fabs(__x); }
+  using ::acos;
+  inline float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+  inline long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+  using ::asin;
+  inline float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+  inline long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+  using ::atan;
+  inline float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+  inline long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+  using ::atan2;
+  inline float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+  inline long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+  template<typename _Tp, typename _Up>
+    inline
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+  using ::ceil;
+  inline float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+  inline long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+  using ::cos;
+  inline float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+  inline long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+  using ::cosh;
+  inline float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+  inline long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+  using ::exp;
+  inline float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+  inline long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+  using ::fabs;
+  inline float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+  inline long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+  using ::floor;
+  inline float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+  inline long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+  using ::fmod;
+  inline float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+  inline long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+  using ::frexp;
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+  using ::ldexp;
+  inline float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+  inline long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+  ldexp(_Tp __x, int __exp)
+  { return __builtin_ldexp(__x, __exp); }
+  using ::log;
+  inline float
+  log(float __x)
+  { return __builtin_logf(__x); }
+  inline long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+  using ::log10;
+  inline float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+  inline long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+  using ::modf;
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+  using ::pow;
+  inline float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+  inline long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+  inline double
+  pow(double __x, int __i)
+  { return __builtin_powi(__x, __i); }
+  inline float
+  pow(float __x, int __n)
+  { return __builtin_powif(__x, __n); }
+  inline long double
+  pow(long double __x, int __n)
+  { return __builtin_powil(__x, __n); }
+  template<typename _Tp, typename _Up>
+    inline
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+  using ::sin;
+  inline float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+  inline long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+  using ::sinh;
+  inline float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+  inline long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+  using ::sqrt;
+  inline float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+  inline long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+  using ::tan;
+  inline float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+  inline long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+  using ::tanh;
+  inline float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+  inline long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    fpclassify(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+      FP_SUBNORMAL, FP_ZERO, __type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isfinite(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isfinite(__type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isinf(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isinf(__type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isnan(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnan(__type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isnormal(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnormal(__type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    signbit(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_signbit(__type(__f));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreater(__type(__f1), __type(__f2));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isgreaterequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isless(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isless(__type(__f1), __type(__f2));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    islessequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessequal(__type(__f1), __type(__f2));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    islessgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessgreater(__type(__f1), __type(__f2));
+    }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isunordered(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isunordered(__type(__f1), __type(__f2));
+    }
+}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T>
+    struct is_bool : mpl::false_ {};
+    template <typename T>
+    struct is_bool<T const> : is_bool<T> {};
+    template <>
+    struct is_bool<bool> : mpl::true_ {};
+    template <typename T>
+    struct is_int : mpl::false_ {};
+    template <typename T>
+    struct is_int<T const> : is_int<T> {};
+    template <>
+    struct is_int<short> : mpl::true_ {};
+    template <>
+    struct is_int<int> : mpl::true_ {};
+    template <>
+    struct is_int<long> : mpl::true_ {};
+    template <>
+    struct is_int<boost::long_long_type> : mpl::true_ {};
+    template <typename T>
+    struct is_uint : mpl::false_ {};
+    template <typename T>
+    struct is_uint<T const> : is_uint<T> {};
+    template <>
+    struct is_uint<unsigned short> : mpl::true_ {};
+    template <>
+    struct is_uint<unsigned int> : mpl::true_ {};
+    template <>
+    struct is_uint<unsigned long> : mpl::true_ {};
+    template <>
+    struct is_uint<boost::ulong_long_type> : mpl::true_ {};
+    template <typename T>
+    struct is_real : mpl::false_ {};
+    template <typename T>
+    struct is_real<T const> : is_uint<T> {};
+    template <>
+    struct is_real<float> : mpl::true_ {};
+    template <>
+    struct is_real<double> : mpl::true_ {};
+    template <>
+    struct is_real<long double> : mpl::true_ {};
+    template <typename T, typename Enable = void>
+    struct absolute_value;
+    template <typename T, typename Enable = void>
+    struct is_negative;
+    template <typename T, typename Enable = void>
+    struct is_zero;
+    template <typename T, typename Enable = void>
+    struct pow10_helper;
+    template <typename T, typename Enable = void>
+    struct is_nan;
+    template <typename T, typename Enable = void>
+    struct is_infinite;
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Enable >
+    struct pow10_helper
+    {
+        static T call(unsigned dim)
+        {
+            using namespace std;
+            return pow(T(10), T(dim));
+        }
+    };
+    template <>
+    struct pow10_helper<unused_type>
+    {
+        static unused_type call(unused_type)
+        {
+            return unused;
+        }
+    };
+    template <typename T>
+    inline T pow10(unsigned dim)
+    {
+        return pow10_helper<T>::call(dim);
+    }
+}}}
+namespace boost{ namespace math
+{
+  namespace tools
+  {
+    template <class To, class T>
+    inline To real_cast(T t)
+    {
+       return static_cast<To>(t);
+    }
+  }
+}
+}
+namespace boost
+{
+   namespace math
+   {
+   template <class T, class Policy>
+   T trunc(const T& v, const Policy& pol);
+   template <class T>
+   T trunc(const T& v);
+   template <class T, class Policy>
+   int itrunc(const T& v, const Policy& pol);
+   template <class T>
+   int itrunc(const T& v);
+   template <class T, class Policy>
+   long ltrunc(const T& v, const Policy& pol);
+   template <class T>
+   long ltrunc(const T& v);
+   template <class T, class Policy>
+   boost::long_long_type lltrunc(const T& v, const Policy& pol);
+   template <class T>
+   boost::long_long_type lltrunc(const T& v);
+   template <class T, class Policy>
+   T round(const T& v, const Policy& pol);
+   template <class T>
+   T round(const T& v);
+   template <class T, class Policy>
+   int iround(const T& v, const Policy& pol);
+   template <class T>
+   int iround(const T& v);
+   template <class T, class Policy>
+   long lround(const T& v, const Policy& pol);
+   template <class T>
+   long lround(const T& v);
+   template <class T, class Policy>
+   boost::long_long_type llround(const T& v, const Policy& pol);
+   template <class T>
+   boost::long_long_type llround(const T& v);
+   template <class T, class Policy>
+   T modf(const T& v, T* ipart, const Policy& pol);
+   template <class T>
+   T modf(const T& v, T* ipart);
+   template <class T, class Policy>
+   T modf(const T& v, int* ipart, const Policy& pol);
+   template <class T>
+   T modf(const T& v, int* ipart);
+   template <class T, class Policy>
+   T modf(const T& v, long* ipart, const Policy& pol);
+   template <class T>
+   T modf(const T& v, long* ipart);
+   template <class T, class Policy>
+   T modf(const T& v, boost::long_long_type* ipart, const Policy& pol);
+   template <class T>
+   T modf(const T& v, boost::long_long_type* ipart);
+   }
+}
+namespace boost{ namespace math{
+namespace tools
+{
+template <class T>
+inline T max (T a, T b, T c)
+{
+   return (std::max)((std::max)(a, b), c);
+}
+template <class T>
+inline T max (T a, T b, T c, T d)
+{
+   return (std::max)((std::max)(a, b), (std::max)(c, d));
+}
+}
+template <class T>
+void suppress_unused_variable_warning(const T&)
+{
+}
+}}
+enum
+  {
+    FE_INEXACT = 1 << (31 - 6),
+    FE_DIVBYZERO = 1 << (31 - 5),
+    FE_UNDERFLOW = 1 << (31 - 4),
+    FE_OVERFLOW = 1 << (31 - 3),
+    FE_INVALID = 1 << (31 - 2),
+    FE_INVALID_SNAN = 1 << (31 - 7),
+    FE_INVALID_ISI = 1 << (31 - 8),
+    FE_INVALID_IDI = 1 << (31 - 9),
+    FE_INVALID_ZDZ = 1 << (31 - 10),
+    FE_INVALID_IMZ = 1 << (31 - 11),
+    FE_INVALID_COMPARE = 1 << (31 - 12),
+    FE_INVALID_SOFTWARE = 1 << (31 - 21),
+    FE_INVALID_SQRT = 1 << (31 - 22),
+    FE_INVALID_INTEGER_CONVERSION = 1 << (31 - 23)
+  };
+enum
+  {
+    FE_TONEAREST = 0,
+    FE_TOWARDZERO = 1,
+    FE_UPWARD = 2,
+    FE_DOWNWARD = 3
+  };
+typedef unsigned int fexcept_t;
+typedef double fenv_t;
+extern const fenv_t __fe_dfl_env;
+extern const fenv_t __fe_enabled_env;
+extern const fenv_t __fe_nonieee_env;
+extern "C" {
+extern const fenv_t *__fe_nomask_env (void);
+extern const fenv_t *__fe_mask_env (void);
+}
+extern "C" {
+extern int feclearexcept (int __excepts) throw ();
+extern int fegetexceptflag (fexcept_t *__flagp, int __excepts) throw ();
+extern int feraiseexcept (int __excepts) throw ();
+extern int fesetexceptflag (__const fexcept_t *__flagp, int __excepts) throw ();
+extern int fetestexcept (int __excepts) throw ();
+extern int fegetround (void) throw ();
+extern int fesetround (int __rounding_direction) throw ();
+extern int fegetenv (fenv_t *__envp) throw ();
+extern int feholdexcept (fenv_t *__envp) throw ();
+extern int fesetenv (__const fenv_t *__envp) throw ();
+extern int feupdateenv (__const fenv_t *__envp) throw ();
+extern int feenableexcept (int __excepts) throw ();
+extern int fedisableexcept (int __excepts) throw ();
+extern int fegetexcept (void) throw ();
+}
+namespace boost{ namespace math{
+   namespace detail
+   {
+   struct fpu_guard
+   {
+      fpu_guard()
+      {
+         fegetexceptflag(&m_flags, (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID));
+         ((__builtin_constant_p ((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)) && (((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)) & (((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID))-1)) == 0 && ((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)) != FE_INVALID) ? (((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)) != 0 ? (__extension__ ({ __asm__ __volatile__ ("mtfsb0 %s0" : : "i#*X"(__builtin_ffs ((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)))); 0; })) : 0) : (feclearexcept) ((FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID)));
+      }
+      ~fpu_guard()
+      {
+         fesetexceptflag(&m_flags, (FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW | FE_INVALID));
+      }
+   private:
+      fexcept_t m_flags;
+   };
+   }
+   }}
+namespace boost
+{
+  namespace math
+  {
+    namespace tools
+    {
+      template <class T>
+      struct promote_arg
+      {
+        typedef typename mpl::if_<is_integral<T>, double, T>::type type;
+      };
+      template <> struct promote_arg<float> { typedef float type; };
+      template <> struct promote_arg<double>{ typedef double type; };
+      template <> struct promote_arg<long double> { typedef long double type; };
+      template <> struct promote_arg<int> { typedef double type; };
+      template <class T1, class T2>
+      struct promote_args_2
+      {
+        typedef typename promote_arg<T1>::type T1P;
+        typedef typename promote_arg<T2>::type T2P;
+        typedef typename mpl::if_<
+          typename mpl::and_<is_floating_point<T1P>, is_floating_point<T2P> >::type,
+          typename mpl::if_< typename mpl::or_<is_same<long double, T1P>, is_same<long double, T2P> >::type,
+            long double,
+            typename mpl::if_< typename mpl::or_<is_same<double, T1P>, is_same<double, T2P> >::type,
+            double,
+          float
+          >::type
+          >::type,
+          typename mpl::if_< typename mpl::and_<mpl::not_<is_floating_point<T2P> >, ::boost::is_convertible<T1P, T2P> >, T2P, T1P>::type>::type type;
+      };
+      template <> struct promote_args_2<float, float> { typedef float type; };
+      template <> struct promote_args_2<double, double>{ typedef double type; };
+      template <> struct promote_args_2<long double, long double> { typedef long double type; };
+      template <> struct promote_args_2<int, int> { typedef double type; };
+      template <> struct promote_args_2<int, float> { typedef double type; };
+      template <> struct promote_args_2<float, int> { typedef double type; };
+      template <> struct promote_args_2<int, double> { typedef double type; };
+      template <> struct promote_args_2<double, int> { typedef double type; };
+      template <> struct promote_args_2<int, long double> { typedef long double type; };
+      template <> struct promote_args_2<long double, int> { typedef long double type; };
+      template <> struct promote_args_2<float, double> { typedef double type; };
+      template <> struct promote_args_2<double, float> { typedef double type; };
+      template <> struct promote_args_2<float, long double> { typedef long double type; };
+      template <> struct promote_args_2<long double, float> { typedef long double type; };
+      template <> struct promote_args_2<double, long double> { typedef long double type; };
+      template <> struct promote_args_2<long double, double> { typedef long double type; };
+      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
+      struct promote_args
+      {
+         typedef typename promote_args_2<
+            typename remove_cv<T1>::type,
+            typename promote_args_2<
+               typename remove_cv<T2>::type,
+               typename promote_args_2<
+                  typename remove_cv<T3>::type,
+                  typename promote_args_2<
+                     typename remove_cv<T4>::type,
+                     typename promote_args_2<
+                        typename remove_cv<T5>::type, typename remove_cv<T6>::type
+                     >::type
+                  >::type
+               >::type
+            >::type
+         >::type type;
+      };
+    }
+  }
+}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct not_equal_to_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct not_equal_to_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct not_equal_to_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct not_equal_to_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct not_equal_to_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct not_equal_to
+    : not_equal_to_impl<
+          typename not_equal_to_tag<N1>::type
+        , typename not_equal_to_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct not_equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< not_equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_equal_to< na , na > result_; typedef not_equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< not_equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< not_equal_to< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct not_equal_to_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N1::value != N2::value ) >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct greater_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct greater_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct greater_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct greater_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct greater_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct greater
+    : greater_impl<
+          typename greater_tag<N1>::type
+        , typename greater_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct greater< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater< na , na > result_; typedef greater< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct greater_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N1::value > N2::value ) >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct less_equal_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct less_equal_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct less_equal_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct less_equal_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct less_equal_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct less_equal
+    : less_equal_impl<
+          typename less_equal_tag<N1>::type
+        , typename less_equal_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct less_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< less_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less_equal< na , na > result_; typedef less_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less_equal< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct less_equal_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N1::value <= N2::value ) >
+    {
+    };
+};
+}}
+namespace boost { namespace mpl {
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct greater_equal_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+        , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+template<> struct greater_equal_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct greater_equal_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename Tag > struct greater_equal_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+template< typename T > struct greater_equal_tag
+{
+    typedef typename T::tag type;
+};
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct greater_equal
+    : greater_equal_impl<
+          typename greater_equal_tag<N1>::type
+        , typename greater_equal_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+};
+template<> struct greater_equal< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : greater_equal< T1 , T2 > { }; }; template< typename Tag > struct lambda< greater_equal< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef greater_equal< na , na > result_; typedef greater_equal< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< greater_equal< T1 , T2 > > : int_<2> { }; template<> struct template_arity< greater_equal< na , na > > : int_<-1> { }; }
+}}
+namespace boost { namespace mpl {
+template<>
+struct greater_equal_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+        : bool_< ( N1::value >= N2::value ) >
+    {
+    };
+};
+}}
+namespace boost{ namespace math{
+namespace tools{
+template <class T>
+int digits();
+template <class T>
+T epsilon();
+}
+namespace policies{
+enum error_policy_type
+{
+   throw_on_error = 0,
+   errno_on_error = 1,
+   ignore_error = 2,
+   user_error = 3
+};
+template <error_policy_type N = throw_on_error> struct domain_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const domain_error<N>*); char test_is_default_arg(const domain_error<throw_on_error>*); template <class T> struct is_domain_error_imp { template <error_policy_type N> static char test(const domain_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_domain_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_domain_error_imp<T>::value>{};
+template <error_policy_type N = throw_on_error> struct pole_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const pole_error<N>*); char test_is_default_arg(const pole_error<throw_on_error>*); template <class T> struct is_pole_error_imp { template <error_policy_type N> static char test(const pole_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_pole_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_pole_error_imp<T>::value>{};
+template <error_policy_type N = throw_on_error> struct overflow_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const overflow_error<N>*); char test_is_default_arg(const overflow_error<throw_on_error>*); template <class T> struct is_overflow_error_imp { template <error_policy_type N> static char test(const overflow_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_overflow_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_overflow_error_imp<T>::value>{};
+template <error_policy_type N = ignore_error> struct underflow_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const underflow_error<N>*); char test_is_default_arg(const underflow_error<ignore_error>*); template <class T> struct is_underflow_error_imp { template <error_policy_type N> static char test(const underflow_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_underflow_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_underflow_error_imp<T>::value>{};
+template <error_policy_type N = ignore_error> struct denorm_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const denorm_error<N>*); char test_is_default_arg(const denorm_error<ignore_error>*); template <class T> struct is_denorm_error_imp { template <error_policy_type N> static char test(const denorm_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_denorm_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_denorm_error_imp<T>::value>{};
+template <error_policy_type N = throw_on_error> struct evaluation_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const evaluation_error<N>*); char test_is_default_arg(const evaluation_error<throw_on_error>*); template <class T> struct is_evaluation_error_imp { template <error_policy_type N> static char test(const evaluation_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_evaluation_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_evaluation_error_imp<T>::value>{};
+template <error_policy_type N = throw_on_error> struct rounding_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const rounding_error<N>*); char test_is_default_arg(const rounding_error<throw_on_error>*); template <class T> struct is_rounding_error_imp { template <error_policy_type N> static char test(const rounding_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_rounding_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_rounding_error_imp<T>::value>{};
+template <error_policy_type N = ignore_error> struct indeterminate_result_error : public boost::mpl::int_<N>{}; namespace detail{ template <error_policy_type N> char test_is_valid_arg(const indeterminate_result_error<N>*); char test_is_default_arg(const indeterminate_result_error<ignore_error>*); template <class T> struct is_indeterminate_result_error_imp { template <error_policy_type N> static char test(const indeterminate_result_error<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_indeterminate_result_error : public boost::mpl::bool_< ::boost::math::policies::detail::is_indeterminate_result_error_imp<T>::value>{};
+template <bool N = true> struct promote_float : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const promote_float<N>*); char test_is_default_arg(const promote_float<true>*); template <class T> struct is_promote_float_imp { template <bool N> static char test(const promote_float<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_promote_float : public boost::mpl::bool_< ::boost::math::policies::detail::is_promote_float_imp<T>::value>{};
+template <bool N = true> struct promote_double : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const promote_double<N>*); char test_is_default_arg(const promote_double<true>*); template <class T> struct is_promote_double_imp { template <bool N> static char test(const promote_double<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_promote_double : public boost::mpl::bool_< ::boost::math::policies::detail::is_promote_double_imp<T>::value>{};
+template <bool N = true> struct assert_undefined : public boost::mpl::bool_<N>{}; namespace detail{ template <bool N> char test_is_valid_arg(const assert_undefined<N>*); char test_is_default_arg(const assert_undefined<true>*); template <class T> struct is_assert_undefined_imp { template <bool N> static char test(const assert_undefined<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_assert_undefined : public boost::mpl::bool_< ::boost::math::policies::detail::is_assert_undefined_imp<T>::value>{};
+enum discrete_quantile_policy_type
+{
+   real,
+   integer_round_outwards,
+   integer_round_inwards,
+   integer_round_down,
+   integer_round_up,
+   integer_round_nearest
+};
+template <discrete_quantile_policy_type N = integer_round_outwards> struct discrete_quantile : public boost::mpl::int_<N>{}; namespace detail{ template <discrete_quantile_policy_type N> char test_is_valid_arg(const discrete_quantile<N>*); char test_is_default_arg(const discrete_quantile<integer_round_outwards>*); template <class T> struct is_discrete_quantile_imp { template <discrete_quantile_policy_type N> static char test(const discrete_quantile<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_discrete_quantile : public boost::mpl::bool_< ::boost::math::policies::detail::is_discrete_quantile_imp<T>::value>{};
+template <int N = 0> struct digits10 : public boost::mpl::int_<N>{}; namespace detail{ template <int N> char test_is_valid_arg(const digits10<N>*); char test_is_default_arg(const digits10<0>*); template <class T> struct is_digits10_imp { template <int N> static char test(const digits10<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_digits10 : public boost::mpl::bool_< ::boost::math::policies::detail::is_digits10_imp<T>::value>{};
+template <int N = 0> struct digits2 : public boost::mpl::int_<N>{}; namespace detail{ template <int N> char test_is_valid_arg(const digits2<N>*); char test_is_default_arg(const digits2<0>*); template <class T> struct is_digits2_imp { template <int N> static char test(const digits2<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_digits2 : public boost::mpl::bool_< ::boost::math::policies::detail::is_digits2_imp<T>::value>{};
+template <unsigned long N = 1000000> struct max_series_iterations : public boost::mpl::int_<N>{}; namespace detail{ template <unsigned long N> char test_is_valid_arg(const max_series_iterations<N>*); char test_is_default_arg(const max_series_iterations<1000000>*); template <class T> struct is_max_series_iterations_imp { template <unsigned long N> static char test(const max_series_iterations<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_max_series_iterations : public boost::mpl::bool_< ::boost::math::policies::detail::is_max_series_iterations_imp<T>::value>{};
+template <unsigned long N = 200> struct max_root_iterations : public boost::mpl::int_<N>{}; namespace detail{ template <unsigned long N> char test_is_valid_arg(const max_root_iterations<N>*); char test_is_default_arg(const max_root_iterations<200>*); template <class T> struct is_max_root_iterations_imp { template <unsigned long N> static char test(const max_root_iterations<N>*); static double test(...); static const bool value = sizeof(test(static_cast<T*>(0))) == 1; }; } template <class T> struct is_max_root_iterations : public boost::mpl::bool_< ::boost::math::policies::detail::is_max_root_iterations_imp<T>::value>{};
+struct default_policy{};
+namespace detail{
+template <class Digits10, class Digits2>
+struct precision
+{
+   typedef typename mpl::if_c<
+      (Digits10::value == 0),
+      digits2<0>,
+      digits2<((Digits10::value + 1) * 1000L) / 301L>
+   >::type digits2_type;
+public:
+   typedef typename mpl::if_c<
+      (Digits2::value > digits2_type::value),
+      Digits2, digits2_type>::type type;
+};
+template <class A, class B, bool b>
+struct select_result
+{
+   typedef A type;
+};
+template <class A, class B>
+struct select_result<A, B, false>
+{
+   typedef typename mpl::deref<B>::type type;
+};
+template <class Seq, class Pred, class DefaultType>
+struct find_arg
+{
+private:
+   typedef typename mpl::find_if<Seq, Pred>::type iter;
+   typedef typename mpl::end<Seq>::type end_type;
+public:
+   typedef typename select_result<
+      DefaultType, iter,
+      ::boost::is_same<iter, end_type>::value>::type type;
+};
+double test_is_valid_arg(...);
+double test_is_default_arg(...);
+char test_is_valid_arg(const default_policy*);
+char test_is_default_arg(const default_policy*);
+template <class T>
+struct is_valid_policy_imp
+{
+   static const bool value = sizeof(::boost::math::policies::detail::test_is_valid_arg(static_cast<T*>(0))) == 1;
+};
+template <class T>
+struct is_default_policy_imp
+{
+   static const bool value = sizeof(::boost::math::policies::detail::test_is_default_arg(static_cast<T*>(0))) == 1;
+};
+template <class T> struct is_valid_policy
+: public mpl::bool_<
+   ::boost::math::policies::detail::is_valid_policy_imp<T>::value>
+{};
+template <class T> struct is_default_policy
+: public mpl::bool_<
+   ::boost::math::policies::detail::is_default_policy_imp<T>::value>
+{
+   template <class U>
+   struct apply
+   {
+      typedef is_default_policy<U> type;
+   };
+};
+template <class Seq, class T, int N>
+struct append_N
+{
+   typedef typename mpl::push_back<Seq, T>::type new_seq;
+   typedef typename append_N<new_seq, T, N-1>::type type;
+};
+template <class Seq, class T>
+struct append_N<Seq, T, 0>
+{
+   typedef Seq type;
+};
+template <bool f, bool d>
+struct default_args
+{
+   typedef promote_float<false> arg1;
+   typedef promote_double<false> arg2;
+};
+template <>
+struct default_args<false, false>
+{
+   typedef default_policy arg1;
+   typedef default_policy arg2;
+};
+template <>
+struct default_args<true, false>
+{
+   typedef promote_float<false> arg1;
+   typedef default_policy arg2;
+};
+template <>
+struct default_args<false, true>
+{
+   typedef promote_double<false> arg1;
+   typedef default_policy arg2;
+};
+typedef default_args<true, true>::arg1 forwarding_arg1;
+typedef default_args<true, true>::arg2 forwarding_arg2;
+}
+template <class A1 = default_policy,
+          class A2 = default_policy,
+          class A3 = default_policy,
+          class A4 = default_policy,
+          class A5 = default_policy,
+          class A6 = default_policy,
+          class A7 = default_policy,
+          class A8 = default_policy,
+          class A9 = default_policy,
+          class A10 = default_policy,
+          class A11 = default_policy,
+          class A12 = default_policy,
+          class A13 = default_policy>
+struct policy
+{
+private:
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A1>::value) == 0 ? false : true) >)> boost_static_assert_typedef_387;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A2>::value) == 0 ? false : true) >)> boost_static_assert_typedef_388;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A3>::value) == 0 ? false : true) >)> boost_static_assert_typedef_389;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A4>::value) == 0 ? false : true) >)> boost_static_assert_typedef_390;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A5>::value) == 0 ? false : true) >)> boost_static_assert_typedef_391;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A6>::value) == 0 ? false : true) >)> boost_static_assert_typedef_392;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A7>::value) == 0 ? false : true) >)> boost_static_assert_typedef_393;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A8>::value) == 0 ? false : true) >)> boost_static_assert_typedef_394;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A9>::value) == 0 ? false : true) >)> boost_static_assert_typedef_395;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A10>::value) == 0 ? false : true) >)> boost_static_assert_typedef_396;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A11>::value) == 0 ? false : true) >)> boost_static_assert_typedef_397;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A12>::value) == 0 ? false : true) >)> boost_static_assert_typedef_398;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::boost::math::policies::detail::is_valid_policy<A13>::value) == 0 ? false : true) >)> boost_static_assert_typedef_399;
+   typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;
+public:
+   typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, domain_error<> >::type domain_error_type;
+   typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, pole_error<> >::type pole_error_type;
+   typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, overflow_error<> >::type overflow_error_type;
+   typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, underflow_error<> >::type underflow_error_type;
+   typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, denorm_error<> >::type denorm_error_type;
+   typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, evaluation_error<> >::type evaluation_error_type;
+   typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, rounding_error<> >::type rounding_error_type;
+   typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, indeterminate_result_error<> >::type indeterminate_result_error_type;
+private:
+   typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
+   typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, digits2<> >::type bits_precision_type;
+public:
+   typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;
+   typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, promote_float<> >::type promote_float_type;
+   typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, promote_double<> >::type promote_double_type;
+   typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, discrete_quantile<> >::type discrete_quantile_type;
+   typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;
+   typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
+   typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;
+};
+template <>
+struct policy<default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
+{
+public:
+   typedef domain_error<> domain_error_type;
+   typedef pole_error<> pole_error_type;
+   typedef overflow_error<> overflow_error_type;
+   typedef underflow_error<> underflow_error_type;
+   typedef denorm_error<> denorm_error_type;
+   typedef evaluation_error<> evaluation_error_type;
+   typedef rounding_error<> rounding_error_type;
+   typedef indeterminate_result_error<> indeterminate_result_error_type;
+   typedef digits2<> precision_type;
+   typedef promote_float<> promote_float_type;
+   typedef promote_double<> promote_double_type;
+   typedef discrete_quantile<> discrete_quantile_type;
+   typedef assert_undefined<> assert_undefined_type;
+   typedef max_series_iterations<> max_series_iterations_type;
+   typedef max_root_iterations<> max_root_iterations_type;
+};
+template <>
+struct policy<detail::forwarding_arg1, detail::forwarding_arg2, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy, default_policy>
+{
+public:
+   typedef domain_error<> domain_error_type;
+   typedef pole_error<> pole_error_type;
+   typedef overflow_error<> overflow_error_type;
+   typedef underflow_error<> underflow_error_type;
+   typedef denorm_error<> denorm_error_type;
+   typedef evaluation_error<> evaluation_error_type;
+   typedef rounding_error<> rounding_error_type;
+   typedef indeterminate_result_error<> indeterminate_result_error_type;
+   typedef digits2<> precision_type;
+   typedef promote_float<false> promote_float_type;
+   typedef promote_double<false> promote_double_type;
+   typedef discrete_quantile<> discrete_quantile_type;
+   typedef assert_undefined<> assert_undefined_type;
+   typedef max_series_iterations<> max_series_iterations_type;
+   typedef max_root_iterations<> max_root_iterations_type;
+};
+template <class Policy,
+          class A1 = default_policy,
+          class A2 = default_policy,
+          class A3 = default_policy,
+          class A4 = default_policy,
+          class A5 = default_policy,
+          class A6 = default_policy,
+          class A7 = default_policy,
+          class A8 = default_policy,
+          class A9 = default_policy,
+          class A10 = default_policy,
+          class A11 = default_policy,
+          class A12 = default_policy,
+          class A13 = default_policy>
+struct normalise
+{
+private:
+   typedef mpl::list<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> arg_list;
+   typedef typename detail::find_arg<arg_list, is_domain_error<mpl::_1>, typename Policy::domain_error_type >::type domain_error_type;
+   typedef typename detail::find_arg<arg_list, is_pole_error<mpl::_1>, typename Policy::pole_error_type >::type pole_error_type;
+   typedef typename detail::find_arg<arg_list, is_overflow_error<mpl::_1>, typename Policy::overflow_error_type >::type overflow_error_type;
+   typedef typename detail::find_arg<arg_list, is_underflow_error<mpl::_1>, typename Policy::underflow_error_type >::type underflow_error_type;
+   typedef typename detail::find_arg<arg_list, is_denorm_error<mpl::_1>, typename Policy::denorm_error_type >::type denorm_error_type;
+   typedef typename detail::find_arg<arg_list, is_evaluation_error<mpl::_1>, typename Policy::evaluation_error_type >::type evaluation_error_type;
+   typedef typename detail::find_arg<arg_list, is_rounding_error<mpl::_1>, typename Policy::rounding_error_type >::type rounding_error_type;
+   typedef typename detail::find_arg<arg_list, is_indeterminate_result_error<mpl::_1>, typename Policy::indeterminate_result_error_type >::type indeterminate_result_error_type;
+   typedef typename detail::find_arg<arg_list, is_digits10<mpl::_1>, digits10<> >::type digits10_type;
+   typedef typename detail::find_arg<arg_list, is_digits2<mpl::_1>, typename Policy::precision_type >::type bits_precision_type;
+   typedef typename detail::precision<digits10_type, bits_precision_type>::type precision_type;
+   typedef typename detail::find_arg<arg_list, is_promote_float<mpl::_1>, typename Policy::promote_float_type >::type promote_float_type;
+   typedef typename detail::find_arg<arg_list, is_promote_double<mpl::_1>, typename Policy::promote_double_type >::type promote_double_type;
+   typedef typename detail::find_arg<arg_list, is_discrete_quantile<mpl::_1>, typename Policy::discrete_quantile_type >::type discrete_quantile_type;
+   typedef typename detail::find_arg<arg_list, is_assert_undefined<mpl::_1>, discrete_quantile<> >::type assert_undefined_type;
+   typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, max_series_iterations<> >::type max_series_iterations_type;
+   typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, max_root_iterations<> >::type max_root_iterations_type;
+   typedef mpl::vector<
+      domain_error_type,
+      pole_error_type,
+      overflow_error_type,
+      underflow_error_type,
+      denorm_error_type,
+      evaluation_error_type,
+      rounding_error_type,
+      indeterminate_result_error_type,
+      precision_type,
+      promote_float_type,
+      promote_double_type,
+      discrete_quantile_type,
+      assert_undefined_type,
+      max_series_iterations_type,
+      max_root_iterations_type> result_list;
+   typedef typename mpl::remove_if<result_list, detail::is_default_policy<mpl::_> >::type reduced_list;
+   typedef typename detail::append_N<reduced_list, default_policy, (14 - ::boost::mpl::size<reduced_list>::value)>::type result_type;
+public:
+   typedef policy<
+      typename mpl::at<result_type, mpl::int_<0> >::type,
+      typename mpl::at<result_type, mpl::int_<1> >::type,
+      typename mpl::at<result_type, mpl::int_<2> >::type,
+      typename mpl::at<result_type, mpl::int_<3> >::type,
+      typename mpl::at<result_type, mpl::int_<4> >::type,
+      typename mpl::at<result_type, mpl::int_<5> >::type,
+      typename mpl::at<result_type, mpl::int_<6> >::type,
+      typename mpl::at<result_type, mpl::int_<7> >::type,
+      typename mpl::at<result_type, mpl::int_<8> >::type,
+      typename mpl::at<result_type, mpl::int_<9> >::type,
+      typename mpl::at<result_type, mpl::int_<10> >::type,
+      typename mpl::at<result_type, mpl::int_<11> >::type,
+      typename mpl::at<result_type, mpl::int_<12> >::type > type;
+};
+template <>
+struct normalise<policy<>,
+          promote_float<false>,
+          promote_double<false>,
+          discrete_quantile<>,
+          assert_undefined<>,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy>
+{
+   typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
+};
+template <>
+struct normalise<policy<detail::forwarding_arg1, detail::forwarding_arg2>,
+          promote_float<false>,
+          promote_double<false>,
+          discrete_quantile<>,
+          assert_undefined<>,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy,
+          default_policy>
+{
+   typedef policy<detail::forwarding_arg1, detail::forwarding_arg2> type;
+};
+inline policy<> make_policy()
+{ return policy<>(); }
+template <class A1>
+inline typename normalise<policy<>, A1>::type make_policy(const A1&)
+{
+   typedef typename normalise<policy<>, A1>::type result_type;
+   return result_type();
+}
+template <class A1, class A2>
+inline typename normalise<policy<>, A1, A2>::type make_policy(const A1&, const A2&)
+{
+   typedef typename normalise<policy<>, A1, A2>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3>
+inline typename normalise<policy<>, A1, A2, A3>::type make_policy(const A1&, const A2&, const A3&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4>
+inline typename normalise<policy<>, A1, A2, A3, A4>::type make_policy(const A1&, const A2&, const A3&, const A4&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>::type result_type;
+   return result_type();
+}
+template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
+inline typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type make_policy(const A1&, const A2&, const A3&, const A4&, const A5&, const A6&, const A7&, const A8&, const A9&, const A10&, const A11&)
+{
+   typedef typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11>::type result_type;
+   return result_type();
+}
+template <class Real, class Policy>
+struct evaluation
+{
+   typedef Real type;
+};
+template <class Policy>
+struct evaluation<float, Policy>
+{
+   typedef typename mpl::if_<typename Policy::promote_float_type, double, float>::type type;
+};
+template <class Policy>
+struct evaluation<double, Policy>
+{
+   typedef typename mpl::if_<typename Policy::promote_double_type, long double, double>::type type;
+};
+template <class Real, class Policy>
+struct precision
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::std::numeric_limits<Real>::radix == 2) || ((::std::numeric_limits<Real>::is_specialized == 0) || (::std::numeric_limits<Real>::digits == 0))) == 0 ? false : true) >)> boost_static_assert_typedef_779;
+   typedef typename Policy::precision_type precision_type;
+   typedef typename mpl::if_c<
+      ((::std::numeric_limits<Real>::is_specialized == 0) || (::std::numeric_limits<Real>::digits == 0)),
+      precision_type,
+      typename mpl::if_c<
+         ((::std::numeric_limits<Real>::digits <= precision_type::value)
+         || (Policy::precision_type::value <= 0)),
+         digits2< ::std::numeric_limits<Real>::digits>,
+         precision_type
+      >::type
+   >::type type;
+};
+namespace detail{
+template <class T, class Policy>
+inline int digits_imp(mpl::true_ const&)
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_822;
+   typedef typename boost::math::policies::precision<T, Policy>::type p_t;
+   return p_t::value;
+}
+template <class T, class Policy>
+inline int digits_imp(mpl::false_ const&)
+{
+   return tools::digits<T>();
+}
+}
+template <class T, class Policy>
+inline int digits()
+{
+   typedef mpl::bool_< std::numeric_limits<T>::is_specialized > tag_type;
+   return detail::digits_imp<T, Policy>(tag_type());
+}
+template <class Policy>
+inline unsigned long get_max_series_iterations()
+{
+   typedef typename Policy::max_series_iterations_type iter_type;
+   return iter_type::value;
+}
+template <class Policy>
+inline unsigned long get_max_root_iterations()
+{
+   typedef typename Policy::max_root_iterations_type iter_type;
+   return iter_type::value;
+}
+namespace detail{
+template <class T, class Digits, class Small, class Default>
+struct series_factor_calc
+{
+   static T get()
+   {
+      return ldexp(T(1.0), 1 - Digits::value);
+   }
+};
+template <class T, class Digits>
+struct series_factor_calc<T, Digits, mpl::true_, mpl::true_>
+{
+   static T get()
+   {
+      return boost::math::tools::epsilon<T>();
+   }
+};
+template <class T, class Digits>
+struct series_factor_calc<T, Digits, mpl::true_, mpl::false_>
+{
+   static T get()
+   {
+      static const boost::uintmax_t v = static_cast<boost::uintmax_t>(1u) << (Digits::value - 1);
+      return 1 / static_cast<T>(v);
+   }
+};
+template <class T, class Digits>
+struct series_factor_calc<T, Digits, mpl::false_, mpl::true_>
+{
+   static T get()
+   {
+      return boost::math::tools::epsilon<T>();
+   }
+};
+template <class T, class Policy>
+inline T get_epsilon_imp(mpl::true_ const&)
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::is_specialized) == 0 ? false : true) >)> boost_static_assert_typedef_900;
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((::std::numeric_limits<T>::radix == 2) == 0 ? false : true) >)> boost_static_assert_typedef_901;
+   typedef typename boost::math::policies::precision<T, Policy>::type p_t;
+   typedef mpl::bool_<p_t::value <= std::numeric_limits<boost::uintmax_t>::digits> is_small_int;
+   typedef mpl::bool_<p_t::value >= std::numeric_limits<T>::digits> is_default_value;
+   return series_factor_calc<T, p_t, is_small_int, is_default_value>::get();
+}
+template <class T, class Policy>
+inline T get_epsilon_imp(mpl::false_ const&)
+{
+   return tools::epsilon<T>();
+}
+}
+template <class T, class Policy>
+inline T get_epsilon()
+{
+   typedef mpl::bool_< (std::numeric_limits<T>::is_specialized && (std::numeric_limits<T>::radix == 2)) > tag_type;
+   return detail::get_epsilon_imp<T, Policy>(tag_type());
+}
+namespace detail{
+template <class A1,
+          class A2,
+          class A3,
+          class A4,
+          class A5,
+          class A6,
+          class A7,
+          class A8,
+          class A9,
+          class A10,
+          class A11>
+char test_is_policy(const policy<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11>*);
+double test_is_policy(...);
+template <class P>
+struct is_policy_imp
+{
+   static const bool value = (sizeof(::boost::math::policies::detail::test_is_policy(static_cast<P*>(0))) == 1);
+};
+}
+template <class P>
+struct is_policy : public mpl::bool_< ::boost::math::policies::detail::is_policy_imp<P>::value> {};
+template <class Policy>
+struct constructor_error_check
+{
+   typedef typename Policy::domain_error_type domain_error_type;
+   typedef typename mpl::if_c<
+      (domain_error_type::value == throw_on_error) || (domain_error_type::value == user_error),
+      mpl::true_,
+      mpl::false_>::type type;
+};
+template <class Policy>
+struct method_error_check
+{
+   typedef typename Policy::domain_error_type domain_error_type;
+   typedef typename mpl::if_c<
+      (domain_error_type::value == throw_on_error) && (domain_error_type::value != user_error),
+      mpl::false_,
+      mpl::true_>::type type;
+};
+}}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp> class complex;
+  template<> class complex<float>;
+  template<> class complex<double>;
+  template<> class complex<long double>;
+  template<typename _Tp> _Tp abs(const complex<_Tp>&);
+  template<typename _Tp> _Tp arg(const complex<_Tp>&);
+  template<typename _Tp> _Tp norm(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
+  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
+                                          const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
+  template<typename _Tp>
+    struct complex
+    {
+      typedef _Tp value_type;
+      complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
+      : _M_real(__r), _M_imag(__i) { }
+      template<typename _Up>
+        complex(const complex<_Up>& __z)
+ : _M_real(__z.real()), _M_imag(__z.imag()) { }
+      _Tp&
+      real() { return _M_real; }
+      const _Tp&
+      real() const { return _M_real; }
+      _Tp&
+      imag() { return _M_imag; }
+      const _Tp&
+      imag() const { return _M_imag; }
+      void
+      real(_Tp __val) { _M_real = __val; }
+      void
+      imag(_Tp __val) { _M_imag = __val; }
+      complex<_Tp>& operator=(const _Tp&);
+      complex<_Tp>&
+      operator+=(const _Tp& __t)
+      {
+ _M_real += __t;
+ return *this;
+      }
+      complex<_Tp>&
+      operator-=(const _Tp& __t)
+      {
+ _M_real -= __t;
+ return *this;
+      }
+      complex<_Tp>& operator*=(const _Tp&);
+      complex<_Tp>& operator/=(const _Tp&);
+      template<typename _Up>
+        complex<_Tp>& operator=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator+=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator-=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator*=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator/=(const complex<_Up>&);
+      const complex __rep() const
+      { return *this; }
+    private:
+      _Tp _M_real;
+      _Tp _M_imag;
+    };
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const _Tp& __t)
+    {
+     _M_real = __t;
+     _M_imag = _Tp();
+     return *this;
+    }
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const _Tp& __t)
+    {
+      _M_real *= __t;
+      _M_imag *= __t;
+      return *this;
+    }
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const _Tp& __t)
+    {
+      _M_real /= __t;
+      _M_imag /= __t;
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const complex<_Up>& __z)
+    {
+      _M_real = __z.real();
+      _M_imag = __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator+=(const complex<_Up>& __z)
+    {
+      _M_real += __z.real();
+      _M_imag += __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator-=(const complex<_Up>& __z)
+    {
+      _M_real -= __z.real();
+      _M_imag -= __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
+      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
+      _M_real = __r;
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
+      const _Tp __n = std::norm(__z);
+      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
+      _M_real = __r / __n;
+      return *this;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r += __x;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r(__x, -__y.imag());
+      __r -= __y.real();
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r *= __x;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x)
+    { return __x; }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x)
+    { return complex<_Tp>(-__x.real(), -__x.imag()); }
+  template<typename _Tp>
+    inline bool
+    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
+  template<typename _Tp>
+    inline bool
+    operator==(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() == __y && __x.imag() == _Tp(); }
+  template<typename _Tp>
+    inline bool
+    operator==(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x == __y.real() && _Tp() == __y.imag(); }
+  template<typename _Tp>
+    inline bool
+    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
+  template<typename _Tp>
+    inline bool
+    operator!=(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() != __y || __x.imag() != _Tp(); }
+  template<typename _Tp>
+    inline bool
+    operator!=(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x != __y.real() || _Tp() != __y.imag(); }
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
+    {
+      _Tp __re_x, __im_x;
+      _CharT __ch;
+      __is >> __ch;
+      if (__ch == '(')
+ {
+   __is >> __re_x >> __ch;
+   if (__ch == ',')
+     {
+       __is >> __im_x >> __ch;
+       if (__ch == ')')
+  __x = complex<_Tp>(__re_x, __im_x);
+       else
+  __is.setstate(ios_base::failbit);
+     }
+   else if (__ch == ')')
+     __x = __re_x;
+   else
+     __is.setstate(ios_base::failbit);
+ }
+      else
+ {
+   __is.putback(__ch);
+   __is >> __re_x;
+   __x = __re_x;
+ }
+      return __is;
+    }
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
+    {
+      basic_ostringstream<_CharT, _Traits> __s;
+      __s.flags(__os.flags());
+      __s.imbue(__os.getloc());
+      __s.precision(__os.precision());
+      __s << '(' << __x.real() << ',' << __x.imag() << ')';
+      return __os << __s.str();
+    }
+  template<typename _Tp>
+    inline _Tp&
+    real(complex<_Tp>& __z)
+    { return __z.real(); }
+  template<typename _Tp>
+    inline const _Tp&
+    real(const complex<_Tp>& __z)
+    { return __z.real(); }
+  template<typename _Tp>
+    inline _Tp&
+    imag(complex<_Tp>& __z)
+    { return __z.imag(); }
+  template<typename _Tp>
+    inline const _Tp&
+    imag(const complex<_Tp>& __z)
+    { return __z.imag(); }
+  template<typename _Tp>
+    inline _Tp
+    __complex_abs(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      const _Tp __s = std::max(abs(__x), abs(__y));
+      if (__s == _Tp())
+        return __s;
+      __x /= __s;
+      __y /= __s;
+      return __s * sqrt(__x * __x + __y * __y);
+    }
+  inline float
+  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
+  inline double
+  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
+  inline long double
+  __complex_abs(const __complex__ long double& __z)
+  { return __builtin_cabsl(__z); }
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
+  template<typename _Tp>
+    inline _Tp
+    __complex_arg(const complex<_Tp>& __z)
+    { return atan2(__z.imag(), __z.real()); }
+  inline float
+  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
+  inline double
+  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
+  inline long double
+  __complex_arg(const __complex__ long double& __z)
+  { return __builtin_cargl(__z); }
+  template<typename _Tp>
+    inline _Tp
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
+  template<bool>
+    struct _Norm_helper
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          const _Tp __x = __z.real();
+          const _Tp __y = __z.imag();
+          return __x * __x + __y * __y;
+        }
+    };
+  template<>
+    struct _Norm_helper<true>
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          _Tp __res = std::abs(__z);
+          return __res * __res;
+        }
+    };
+  template<typename _Tp>
+    inline _Tp
+    norm(const complex<_Tp>& __z)
+    {
+      return _Norm_helper<__is_floating<_Tp>::__value
+ && !0>::_S_do_it(__z);
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    polar(const _Tp& __rho, const _Tp& __theta)
+    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    conj(const complex<_Tp>& __z)
+    { return complex<_Tp>(__z.real(), -__z.imag()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cos(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
+    }
+  inline __complex__ float
+  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
+  inline __complex__ double
+  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
+  inline __complex__ long double
+  __complex_cos(const __complex__ long double& __z)
+  { return __builtin_ccosl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cosh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
+    }
+  inline __complex__ float
+  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
+  inline __complex__ double
+  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
+  inline __complex__ long double
+  __complex_cosh(const __complex__ long double& __z)
+  { return __builtin_ccoshl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_exp(const complex<_Tp>& __z)
+    { return std::polar(exp(__z.real()), __z.imag()); }
+  inline __complex__ float
+  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
+  inline __complex__ double
+  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
+  inline __complex__ long double
+  __complex_exp(const __complex__ long double& __z)
+  { return __builtin_cexpl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_log(const complex<_Tp>& __z)
+    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
+  inline __complex__ float
+  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
+  inline __complex__ double
+  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
+  inline __complex__ long double
+  __complex_log(const __complex__ long double& __z)
+  { return __builtin_clogl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    log10(const complex<_Tp>& __z)
+    { return std::log(__z) / log(_Tp(10.0)); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sin(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
+    }
+  inline __complex__ float
+  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
+  inline __complex__ double
+  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
+  inline __complex__ long double
+  __complex_sin(const __complex__ long double& __z)
+  { return __builtin_csinl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sinh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
+    }
+  inline __complex__ float
+  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
+  inline __complex__ double
+  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
+  inline __complex__ long double
+  __complex_sinh(const __complex__ long double& __z)
+  { return __builtin_csinhl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_sqrt(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      if (__x == _Tp())
+        {
+          _Tp __t = sqrt(abs(__y) / 2);
+          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
+        }
+      else
+        {
+          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
+          _Tp __u = __t / 2;
+          return __x > _Tp()
+            ? complex<_Tp>(__u, __y / __t)
+            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
+        }
+    }
+  inline __complex__ float
+  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
+  inline __complex__ double
+  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
+  inline __complex__ long double
+  __complex_sqrt(const __complex__ long double& __z)
+  { return __builtin_csqrtl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tan(const complex<_Tp>& __z)
+    { return std::sin(__z) / std::cos(__z); }
+  inline __complex__ float
+  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
+  inline __complex__ double
+  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
+  inline __complex__ long double
+  __complex_tan(const __complex__ long double& __z)
+  { return __builtin_ctanl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tanh(const complex<_Tp>& __z)
+    { return std::sinh(__z) / std::cosh(__z); }
+  inline __complex__ float
+  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
+  inline __complex__ double
+  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
+  inline __complex__ long double
+  __complex_tanh(const __complex__ long double& __z)
+  { return __builtin_ctanhl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
+    {
+      complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
+      while (__n >>= 1)
+        {
+          __x *= __x;
+          if (__n % 2)
+            __y *= __x;
+        }
+      return __y;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __z, int __n)
+    {
+      return __n < 0
+        ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n)
+        : std::__complex_pow_unsigned(__z, __n);
+    }
+  template<typename _Tp>
+    complex<_Tp>
+    pow(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      if (__x.imag() == _Tp() && __x.real() > _Tp())
+        return pow(__x.real(), __y);
+      complex<_Tp> __t = std::log(__x);
+      return std::polar(exp(__y * __t.real()), __y * __t.imag());
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
+  inline __complex__ float
+  __complex_pow(__complex__ float __x, __complex__ float __y)
+  { return __builtin_cpowf(__x, __y); }
+  inline __complex__ double
+  __complex_pow(__complex__ double __x, __complex__ double __y)
+  { return __builtin_cpow(__x, __y); }
+  inline __complex__ long double
+  __complex_pow(const __complex__ long double& __x,
+  const __complex__ long double& __y)
+  { return __builtin_cpowl(__x, __y); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __complex_pow(__x.__rep(), __y.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
+          __y.imag() * log(__x))
+                  : std::pow(complex<_Tp>(__x), __y);
+    }
+  template<>
+    struct complex<float>
+    {
+      typedef float value_type;
+      typedef __complex__ float _ComplexT;
+      complex(_ComplexT __z) : _M_value(__z) { }
+      complex(float __r = 0.0f, float __i = 0.0f)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+      explicit complex(const complex<double>&);
+      explicit complex(const complex<long double>&);
+      float&
+      real() { return __real__ _M_value; }
+      const float&
+      real() const { return __real__ _M_value; }
+      float&
+      imag() { return __imag__ _M_value; }
+      const float&
+      imag() const { return __imag__ _M_value; }
+      void
+      real(float __val) { __real__ _M_value = __val; }
+      void
+      imag(float __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(float __f)
+      {
+ _M_value = __f;
+ return *this;
+      }
+      complex&
+      operator+=(float __f)
+      {
+ _M_value += __f;
+ return *this;
+      }
+      complex&
+      operator-=(float __f)
+      {
+ _M_value -= __f;
+ return *this;
+      }
+      complex&
+      operator*=(float __f)
+      {
+ _M_value *= __f;
+ return *this;
+      }
+      complex&
+      operator/=(float __f)
+      {
+ _M_value /= __f;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      const _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  template<>
+    struct complex<double>
+    {
+      typedef double value_type;
+      typedef __complex__ double _ComplexT;
+      complex(_ComplexT __z) : _M_value(__z) { }
+      complex(double __r = 0.0, double __i = 0.0)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+      complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+      explicit complex(const complex<long double>&);
+      double&
+      real() { return __real__ _M_value; }
+      const double&
+      real() const { return __real__ _M_value; }
+      double&
+      imag() { return __imag__ _M_value; }
+      const double&
+      imag() const { return __imag__ _M_value; }
+      void
+      real(double __val) { __real__ _M_value = __val; }
+      void
+      imag(double __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(double __d)
+      {
+ _M_value = __d;
+ return *this;
+      }
+      complex&
+      operator+=(double __d)
+      {
+ _M_value += __d;
+ return *this;
+      }
+      complex&
+      operator-=(double __d)
+      {
+ _M_value -= __d;
+ return *this;
+      }
+      complex&
+      operator*=(double __d)
+      {
+ _M_value *= __d;
+ return *this;
+      }
+      complex&
+      operator/=(double __d)
+      {
+ _M_value /= __d;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      const _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  template<>
+    struct complex<long double>
+    {
+      typedef long double value_type;
+      typedef __complex__ long double _ComplexT;
+      complex(_ComplexT __z) : _M_value(__z) { }
+      complex(long double __r = 0.0L,
+     long double __i = 0.0L)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+      complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+      complex(const complex<double>& __z)
+      : _M_value(__z.__rep()) { }
+      long double&
+      real() { return __real__ _M_value; }
+      const long double&
+      real() const { return __real__ _M_value; }
+      long double&
+      imag() { return __imag__ _M_value; }
+      const long double&
+      imag() const { return __imag__ _M_value; }
+      void
+      real(long double __val) { __real__ _M_value = __val; }
+      void
+      imag(long double __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(long double __r)
+      {
+ _M_value = __r;
+ return *this;
+      }
+      complex&
+      operator+=(long double __r)
+      {
+ _M_value += __r;
+ return *this;
+      }
+      complex&
+      operator-=(long double __r)
+      {
+ _M_value -= __r;
+ return *this;
+      }
+      complex&
+      operator*=(long double __r)
+      {
+ _M_value *= __r;
+ return *this;
+      }
+      complex&
+      operator/=(long double __r)
+      {
+ _M_value /= __r;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      const _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  inline
+  complex<float>::complex(const complex<double>& __z)
+  : _M_value(__z.__rep()) { }
+  inline
+  complex<float>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+  inline
+  complex<double>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+  extern template istream& operator>>(istream&, complex<float>&);
+  extern template ostream& operator<<(ostream&, const complex<float>&);
+  extern template istream& operator>>(istream&, complex<double>&);
+  extern template ostream& operator<<(ostream&, const complex<double>&);
+  extern template istream& operator>>(istream&, complex<long double>&);
+  extern template ostream& operator<<(ostream&, const complex<long double>&);
+  extern template wistream& operator>>(wistream&, complex<float>&);
+  extern template wostream& operator<<(wostream&, const complex<float>&);
+  extern template wistream& operator>>(wistream&, complex<double>&);
+  extern template wostream& operator<<(wostream&, const complex<double>&);
+  extern template wistream& operator>>(wistream&, complex<long double>&);
+  extern template wostream& operator<<(wostream&, const complex<long double>&);
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, _Up>
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  template<typename _Tp, typename _Up>
+    struct __promote_2<_Tp, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+}
+namespace boost
+{
+   namespace math
+   {
+   template <class RT1, class RT2>
+   typename tools::promote_args<RT1, RT2>::type
+         beta(RT1 a, RT2 b);
+   template <class RT1, class RT2, class A>
+   typename tools::promote_args<RT1, RT2, A>::type
+         beta(RT1 a, RT2 b, A x);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         beta(RT1 a, RT2 b, RT3 x, const Policy& pol);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         betac(RT1 a, RT2 b, RT3 x);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         betac(RT1 a, RT2 b, RT3 x, const Policy& pol);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta(RT1 a, RT2 b, RT3 x);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta(RT1 a, RT2 b, RT3 x, const Policy& pol);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac(RT1 a, RT2 b, RT3 x);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac(RT1 a, RT2 b, RT3 x, const Policy& pol);
+   template <class T1, class T2, class T3, class T4>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ibeta_inv(T1 a, T2 b, T3 p, T4* py);
+   template <class T1, class T2, class T3, class T4, class Policy>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ibeta_inv(T1 a, T2 b, T3 p, T4* py, const Policy& pol);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_inv(RT1 a, RT2 b, RT3 p);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_inv(RT1 a, RT2 b, RT3 p, const Policy&);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_inva(RT1 a, RT2 b, RT3 p);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_inva(RT1 a, RT2 b, RT3 p, const Policy&);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_invb(RT1 a, RT2 b, RT3 p);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_invb(RT1 a, RT2 b, RT3 p, const Policy&);
+   template <class T1, class T2, class T3, class T4>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ibetac_inv(T1 a, T2 b, T3 q, T4* py);
+   template <class T1, class T2, class T3, class T4, class Policy>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ibetac_inv(T1 a, T2 b, T3 q, T4* py, const Policy& pol);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_inv(RT1 a, RT2 b, RT3 q);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_inv(RT1 a, RT2 b, RT3 q, const Policy&);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_inva(RT1 a, RT2 b, RT3 q);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_inva(RT1 a, RT2 b, RT3 q, const Policy&);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_invb(RT1 a, RT2 b, RT3 q);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibetac_invb(RT1 a, RT2 b, RT3 q, const Policy&);
+   template <class RT1, class RT2, class RT3>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_derivative(RT1 a, RT2 b, RT3 x);
+   template <class RT1, class RT2, class RT3, class Policy>
+   typename tools::promote_args<RT1, RT2, RT3>::type
+         ibeta_derivative(RT1 a, RT2 b, RT3 x, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type erf(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type erf(RT z, const Policy&);
+   template <class RT>
+   typename tools::promote_args<RT>::type erfc(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type erfc(RT z, const Policy&);
+   template <class RT>
+   typename tools::promote_args<RT>::type erf_inv(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type erf_inv(RT z, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type erfc_inv(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type erfc_inv(RT z, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+         legendre_next(unsigned l, T1 x, T2 Pl, T3 Plm1);
+   template <class T>
+   typename tools::promote_args<T>::type
+         legendre_p(int l, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type
+         legendre_p(int l, T x, const Policy& pol);
+   template <class T>
+   typename tools::promote_args<T>::type
+         legendre_q(unsigned l, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type
+         legendre_q(unsigned l, T x, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+         legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1);
+   template <class T>
+   typename tools::promote_args<T>::type
+         legendre_p(int l, int m, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type
+         legendre_p(int l, int m, T x, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+         laguerre_next(unsigned n, T1 x, T2 Ln, T3 Lnm1);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+      laguerre_next(unsigned n, unsigned l, T1 x, T2 Pl, T3 Plm1);
+   template <class T>
+   typename tools::promote_args<T>::type
+      laguerre(unsigned n, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type
+      laguerre(unsigned n, unsigned m, T x, const Policy& pol);
+   template <class T1, class T2>
+   struct laguerre_result
+   {
+      typedef typename mpl::if_<
+         policies::is_policy<T2>,
+         typename tools::promote_args<T1>::type,
+         typename tools::promote_args<T2>::type
+      >::type type;
+   };
+   template <class T1, class T2>
+   typename laguerre_result<T1, T2>::type
+      laguerre(unsigned n, T1 m, T2 x);
+   template <class T>
+   typename tools::promote_args<T>::type
+      hermite(unsigned n, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type
+      hermite(unsigned n, T x, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+      hermite_next(unsigned n, T1 x, T2 Hn, T3 Hnm1);
+   template <class T1, class T2>
+   std::complex<typename tools::promote_args<T1, T2>::type>
+         spherical_harmonic(unsigned n, int m, T1 theta, T2 phi);
+   template <class T1, class T2, class Policy>
+   std::complex<typename tools::promote_args<T1, T2>::type>
+      spherical_harmonic(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type
+         spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type
+      spherical_harmonic_r(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type
+         spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type
+      spherical_harmonic_i(unsigned n, int m, T1 theta, T2 phi, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+         ellint_rf(T1 x, T2 y, T3 z);
+   template <class T1, class T2, class T3, class Policy>
+   typename tools::promote_args<T1, T2, T3>::type
+         ellint_rf(T1 x, T2 y, T3 z, const Policy& pol);
+   template <class T1, class T2, class T3>
+   typename tools::promote_args<T1, T2, T3>::type
+         ellint_rd(T1 x, T2 y, T3 z);
+   template <class T1, class T2, class T3, class Policy>
+   typename tools::promote_args<T1, T2, T3>::type
+         ellint_rd(T1 x, T2 y, T3 z, const Policy& pol);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type
+         ellint_rc(T1 x, T2 y);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type
+         ellint_rc(T1 x, T2 y, const Policy& pol);
+   template <class T1, class T2, class T3, class T4>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ellint_rj(T1 x, T2 y, T3 z, T4 p);
+   template <class T1, class T2, class T3, class T4, class Policy>
+   typename tools::promote_args<T1, T2, T3, T4>::type
+         ellint_rj(T1 x, T2 y, T3 z, T4 p, const Policy& pol);
+   template <typename T>
+   typename tools::promote_args<T>::type ellint_2(T k);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type ellint_2(T1 k, T2 phi, const Policy& pol);
+   template <typename T>
+   typename tools::promote_args<T>::type ellint_1(T k);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type ellint_1(T1 k, T2 phi, const Policy& pol);
+   namespace detail{
+   template <class T, class U, class V>
+   struct ellint_3_result
+   {
+      typedef typename mpl::if_<
+         policies::is_policy<V>,
+         typename tools::promote_args<T, U>::type,
+         typename tools::promote_args<T, U, V>::type
+      >::type type;
+   };
+   }
+   template <class T1, class T2, class T3>
+   typename detail::ellint_3_result<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi);
+   template <class T1, class T2, class T3, class Policy>
+   typename tools::promote_args<T1, T2, T3>::type ellint_3(T1 k, T2 v, T3 phi, const Policy& pol);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type ellint_3(T1 k, T2 v);
+   template <class RT>
+   struct max_factorial;
+   template <class RT>
+   RT factorial(unsigned int);
+   template <class RT, class Policy>
+   RT factorial(unsigned int, const Policy& pol);
+   template <class RT>
+   RT unchecked_factorial(unsigned int );
+   template <class RT>
+   RT double_factorial(unsigned i);
+   template <class RT, class Policy>
+   RT double_factorial(unsigned i, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type falling_factorial(RT x, unsigned n, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type rising_factorial(RT x, int n);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type rising_factorial(RT x, int n, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type tgamma(RT z);
+   template <class RT>
+   typename tools::promote_args<RT>::type tgamma1pm1(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type tgamma1pm1(RT z, const Policy& pol);
+   template <class RT1, class RT2>
+   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z);
+   template <class RT1, class RT2, class Policy>
+   typename tools::promote_args<RT1, RT2>::type tgamma(RT1 a, RT2 z, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type lgamma(RT z, int* sign);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type lgamma(RT z, int* sign, const Policy& pol);
+   template <class RT>
+   typename tools::promote_args<RT>::type lgamma(RT x);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type lgamma(RT x, const Policy& pol);
+   template <class RT1, class RT2>
+   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z);
+   template <class RT1, class RT2, class Policy>
+   typename tools::promote_args<RT1, RT2>::type tgamma_lower(RT1 a, RT2 z, const Policy&);
+   template <class RT1, class RT2>
+   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z);
+   template <class RT1, class RT2, class Policy>
+   typename tools::promote_args<RT1, RT2>::type gamma_q(RT1 a, RT2 z, const Policy&);
+   template <class RT1, class RT2>
+   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z);
+   template <class RT1, class RT2, class Policy>
+   typename tools::promote_args<RT1, RT2>::type gamma_p(RT1 a, RT2 z, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type tgamma_delta_ratio(T1 z, T2 delta, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type tgamma_ratio(T1 a, T2 b, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type gamma_p_derivative(T1 a, T2 x, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type gamma_p_inva(T1 a, T2 p);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type gamma_p_inv(T1 a, T2 p, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type gamma_q_inv(T1 a, T2 q, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type gamma_q_inva(T1 a, T2 q, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type digamma(T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type digamma(T x, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type
+         hypot(T1 x, T2 y);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type
+         hypot(T1 x, T2 y, const Policy&);
+   template <class RT>
+   typename tools::promote_args<RT>::type cbrt(RT z);
+   template <class RT, class Policy>
+   typename tools::promote_args<RT>::type cbrt(RT z, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type log1p(T);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type log1p(T, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type log1pmx(T);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type log1pmx(T, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type expm1(T);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type expm1(T, const Policy&);
+   template <class T1, class T2>
+   typename tools::promote_args<T1, T2>::type
+         powm1(const T1 a, const T2 z);
+   template <class T1, class T2, class Policy>
+   typename tools::promote_args<T1, T2>::type
+         powm1(const T1 a, const T2 z, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type sqrt1pm1(const T& val);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type sqrt1pm1(const T& val, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type sinc_pi(T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type sinc_pi(T x, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type sinhc_pi(T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type sinhc_pi(T x, const Policy&);
+   template<typename T>
+   typename tools::promote_args<T>::type asinh(T x);
+   template<typename T, class Policy>
+   typename tools::promote_args<T>::type asinh(T x, const Policy&);
+   template<typename T>
+   typename tools::promote_args<T>::type acosh(T x);
+   template<typename T, class Policy>
+   typename tools::promote_args<T>::type acosh(T x, const Policy&);
+   template<typename T>
+   typename tools::promote_args<T>::type atanh(T x);
+   template<typename T, class Policy>
+   typename tools::promote_args<T>::type atanh(T x, const Policy&);
+   namespace detail{
+      typedef mpl::int_<0> bessel_no_int_tag;
+      typedef mpl::int_<1> bessel_maybe_int_tag;
+      typedef mpl::int_<2> bessel_int_tag;
+      template <class T1, class T2, class Policy>
+      struct bessel_traits
+      {
+         typedef typename tools::promote_args<
+            T1, T2
+         >::type result_type;
+         typedef typename policies::precision<result_type, Policy>::type precision_type;
+         typedef typename mpl::if_<
+            mpl::or_<
+               mpl::less_equal<precision_type, mpl::int_<0> >,
+               mpl::greater<precision_type, mpl::int_<64> > >,
+            bessel_no_int_tag,
+            typename mpl::if_<
+               is_integral<T1>,
+               bessel_int_tag,
+               bessel_maybe_int_tag
+            >::type
+         >::type optimisation_tag;
+      };
+   }
+   template <class T1, class T2, class Policy>
+   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_j(T1 v, T2 x, const Policy& pol);
+   template <class T1, class T2>
+   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_j(T1 v, T2 x);
+   template <class T, class Policy>
+   typename detail::bessel_traits<T, T, Policy>::result_type sph_bessel(unsigned v, T x, const Policy& pol);
+   template <class T>
+   typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_bessel(unsigned v, T x);
+   template <class T1, class T2, class Policy>
+   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_i(T1 v, T2 x, const Policy& pol);
+   template <class T1, class T2>
+   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_i(T1 v, T2 x);
+   template <class T1, class T2, class Policy>
+   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(T1 v, T2 x, const Policy& pol);
+   template <class T1, class T2>
+   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_bessel_k(T1 v, T2 x);
+   template <class T1, class T2, class Policy>
+   typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_neumann(T1 v, T2 x, const Policy& pol);
+   template <class T1, class T2>
+   typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type cyl_neumann(T1 v, T2 x);
+   template <class T, class Policy>
+   typename detail::bessel_traits<T, T, Policy>::result_type sph_neumann(unsigned v, T x, const Policy& pol);
+   template <class T>
+   typename detail::bessel_traits<T, T, policies::policy<> >::result_type sph_neumann(unsigned v, T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type sin_pi(T x, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type sin_pi(T x);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type cos_pi(T x, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type cos_pi(T x);
+   template <class T>
+   int fpclassify (T t);
+   template <class T>
+   bool isfinite (T z);
+   template <class T>
+   bool isinf (T t);
+   template <class T>
+   bool isnan (T t);
+   template <class T>
+   bool isnormal (T t);
+   template<class T>
+   int signbit (T x);
+   template <class T>
+   int sign (const T& z);
+   template <class T>
+   T copysign (const T& x, const T& y);
+   template <class T>
+   T changesign (const T& z);
+   namespace detail{
+   template <class T, class U>
+   struct expint_result
+   {
+      typedef typename mpl::if_<
+         policies::is_policy<U>,
+         typename tools::promote_args<T>::type,
+         typename tools::promote_args<U>::type
+      >::type type;
+   };
+   }
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type expint(unsigned n, T z, const Policy&);
+   template <class T, class U>
+   typename detail::expint_result<T, U>::type expint(T const z, U const u);
+   template <class T>
+   typename tools::promote_args<T>::type expint(T z);
+   template <class T, class Policy>
+   typename tools::promote_args<T>::type zeta(T s, const Policy&);
+   template <class T>
+   typename tools::promote_args<T>::type zeta(T s);
+   template <int N, typename T, class Policy>
+   typename tools::promote_args<T>::type pow(T base, const Policy& policy);
+   template <int N, typename T>
+   typename tools::promote_args<T>::type pow(T base);
+   template <class T, class Policy>
+   T nextafter(const T&, const T&, const Policy&);
+   template <class T>
+   T nextafter(const T&, const T&);
+   template <class T, class Policy>
+   T float_next(const T&, const Policy&);
+   template <class T>
+   T float_next(const T&);
+   template <class T, class Policy>
+   T float_prior(const T&, const Policy&);
+   template <class T>
+   T float_prior(const T&);
+   template <class T, class Policy>
+   T float_distance(const T&, const T&, const Policy&);
+   template <class T>
+   T float_distance(const T&, const T&);
+    }
+}
+namespace boost {
+namespace math {
+namespace detail {
+struct native_tag {};
+template <bool has_limits>
+struct generic_tag {};
+struct ieee_tag {};
+struct ieee_copy_all_bits_tag : public ieee_tag {};
+struct ieee_copy_leading_bits_tag : public ieee_tag {};
+struct unknown_precision{};
+struct single_precision {};
+struct double_precision {};
+struct extended_double_precision {};
+template<class T> struct fp_traits_native
+{
+    typedef native_tag method;
+};
+template<class T, class U> struct fp_traits_non_native
+{
+   typedef generic_tag<std::numeric_limits<T>::is_specialized> method;
+};
+template<> struct fp_traits_non_native<float, single_precision>
+{
+    typedef ieee_copy_all_bits_tag method;
+    static const uint32_t sign = 0x80000000u;
+    static const uint32_t exponent = 0x7f800000;
+    static const uint32_t flag = 0x00000000;
+    static const uint32_t significand = 0x007fffff;
+    typedef uint32_t bits;
+    static void get_bits(float x, uint32_t& a) { std::memcpy(&a, &x, 4); }
+    static void set_bits(float& x, uint32_t a) { std::memcpy(&x, &a, 4); }
+};
+template<> struct fp_traits_non_native<double, double_precision>
+{
+    typedef ieee_copy_all_bits_tag method;
+    static const uint64_t sign = ((uint64_t)0x80000000u) << 32;
+    static const uint64_t exponent = ((uint64_t)0x7ff00000) << 32;
+    static const uint64_t flag = 0;
+    static const uint64_t significand
+        = (((uint64_t)0x000fffff) << 32) + ((uint64_t)0xffffffffu);
+    typedef uint64_t bits;
+    static void get_bits(double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
+    static void set_bits(double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
+};
+template<> struct fp_traits_non_native<long double, double_precision>
+{
+    typedef ieee_copy_all_bits_tag method;
+    static const uint64_t sign = (uint64_t)0x80000000u << 32;
+    static const uint64_t exponent = (uint64_t)0x7ff00000 << 32;
+    static const uint64_t flag = 0;
+    static const uint64_t significand
+        = ((uint64_t)0x000fffff << 32) + (uint64_t)0xffffffffu;
+    typedef uint64_t bits;
+    static void get_bits(long double x, uint64_t& a) { std::memcpy(&a, &x, 8); }
+    static void set_bits(long double& x, uint64_t a) { std::memcpy(&x, &a, 8); }
+};
+template<>
+struct fp_traits_non_native<long double, extended_double_precision>
+{
+    typedef ieee_copy_leading_bits_tag method;
+    static const uint32_t sign = 0x80000000u;
+    static const uint32_t exponent = 0x7ff00000;
+    static const uint32_t flag = 0x00000000;
+    static const uint32_t significand = 0x000fffff;
+    typedef uint32_t bits;
+    static void get_bits(long double x, uint32_t& a)
+    {
+        std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + offset_, 4);
+    }
+    static void set_bits(long double& x, uint32_t a)
+    {
+        std::memcpy(reinterpret_cast<unsigned char*>(&x) + offset_, &a, 4);
+    }
+private:
+    static const int offset_ = 0;
+};
+template<int n, bool fp> struct size_to_precision
+{
+   typedef unknown_precision type;
+};
+template<> struct size_to_precision<4, true>
+{
+    typedef single_precision type;
+};
+template<> struct size_to_precision<8, true>
+{
+    typedef double_precision type;
+};
+template<> struct size_to_precision<10, true>
+{
+    typedef extended_double_precision type;
+};
+template<> struct size_to_precision<12, true>
+{
+    typedef extended_double_precision type;
+};
+template<> struct size_to_precision<16, true>
+{
+    typedef extended_double_precision type;
+};
+template <class T>
+struct select_native
+{
+    typedef typename size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
+    typedef fp_traits_non_native<T, precision> type;
+};
+template<>
+struct select_native<float>
+{
+    typedef fp_traits_native<float> type;
+};
+template<>
+struct select_native<double>
+{
+    typedef fp_traits_native<double> type;
+};
+template<>
+struct select_native<long double>
+{
+    typedef fp_traits_native<long double> type;
+};
+template<class T> struct fp_traits
+{
+    typedef typename size_to_precision<sizeof(T), ::boost::is_floating_point<T>::value>::type precision;
+    typedef typename select_native<T>::type type;
+    typedef fp_traits_non_native<T, precision> sign_change_type;
+};
+}
+}
+}
+namespace boost{
+namespace math_detail{
+template <class T>
+inline bool is_nan_helper(T t, const boost::true_type&)
+{
+   return (::std:: fpclassify(t) == (int)FP_NAN);
+}
+template <class T>
+inline bool is_nan_helper(T, const boost::false_type&)
+{
+   return false;
+}
+}
+namespace math{
+namespace detail{
+template <class T>
+inline int fpclassify_imp (T t, const native_tag&)
+{
+   return (std::fpclassify)(t);
+}
+template <class T>
+inline int fpclassify_imp (T t, const generic_tag<true>&)
+{
+   ;
+   if(::boost::math_detail::is_nan_helper(t, ::boost::is_floating_point<T>()))
+      return FP_NAN;
+   T at = (t < T(0)) ? -t : t;
+   if(at <= (std::numeric_limits<T>::max)())
+   {
+      if(at >= (std::numeric_limits<T>::min)())
+         return FP_NORMAL;
+      return (at != 0) ? FP_SUBNORMAL : FP_ZERO;
+   }
+   else if(at > (std::numeric_limits<T>::max)())
+      return FP_INFINITE;
+   return FP_NAN;
+}
+template <class T>
+inline int fpclassify_imp (T t, const generic_tag<false>&)
+{
+   ;
+   return t == 0 ? FP_ZERO : FP_NORMAL;
+}
+template<class T>
+int fpclassify_imp (T x, ieee_copy_all_bits_tag)
+{
+   typedef typename fp_traits<T>::type traits;
+   ;
+   typename traits::bits a;
+   traits::get_bits(x,a);
+   ;
+   a &= traits::exponent | traits::flag | traits::significand;
+   ;
+   ;
+   if(a <= traits::significand) {
+      if(a == 0)
+         return FP_ZERO;
+      else
+         return FP_SUBNORMAL;
+   }
+   if(a < traits::exponent) return FP_NORMAL;
+   a &= traits::significand;
+   if(a == 0) return FP_INFINITE;
+   return FP_NAN;
+}
+template<class T>
+int fpclassify_imp (T x, ieee_copy_leading_bits_tag)
+{
+   typedef typename fp_traits<T>::type traits;
+   ;
+   typename traits::bits a;
+   traits::get_bits(x,a);
+   a &= traits::exponent | traits::flag | traits::significand;
+   if(a <= traits::significand) {
+      if(x == 0)
+         return FP_ZERO;
+      else
+         return FP_SUBNORMAL;
+   }
+   if(a < traits::exponent) return FP_NORMAL;
+   a &= traits::significand;
+   traits::set_bits(x,a);
+   if(x == 0) return FP_INFINITE;
+   return FP_NAN;
+}
+}
+template <class T>
+inline int fpclassify (T t)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   return detail::fpclassify_imp(t, method());
+}
+namespace detail {
+    template<class T>
+    inline bool isfinite_impl(T x, native_tag const&)
+    {
+        return (std::isfinite)(x);
+    }
+    template<class T>
+    inline bool isfinite_impl(T x, generic_tag<true> const&)
+    {
+        return x >= -(std::numeric_limits<T>::max)()
+            && x <= (std::numeric_limits<T>::max)();
+    }
+    template<class T>
+    inline bool isfinite_impl(T x, generic_tag<false> const&)
+    {
+       (void)x;
+       return true;
+    }
+    template<class T>
+    inline bool isfinite_impl(T x, ieee_tag const&)
+    {
+        typedef typename detail::fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent;
+        return a != traits::exponent;
+    }
+}
+template<class T>
+inline bool (isfinite)(T x)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::isfinite_impl(x, method());
+}
+namespace detail {
+    template<class T>
+    inline bool isnormal_impl(T x, native_tag const&)
+    {
+        return (std::isnormal)(x);
+    }
+    template<class T>
+    inline bool isnormal_impl(T x, generic_tag<true> const&)
+    {
+        if(x < 0) x = -x;
+        return x >= (std::numeric_limits<T>::min)()
+            && x <= (std::numeric_limits<T>::max)();
+    }
+    template<class T>
+    inline bool isnormal_impl(T x, generic_tag<false> const&)
+    {
+       return !(x == 0);
+    }
+    template<class T>
+    inline bool isnormal_impl(T x, ieee_tag const&)
+    {
+        typedef typename detail::fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent | traits::flag;
+        return (a != 0) && (a < traits::exponent);
+    }
+}
+template<class T>
+inline bool (isnormal)(T x)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::isnormal_impl(x, method());
+}
+namespace detail {
+    template<class T>
+    inline bool isinf_impl(T x, native_tag const&)
+    {
+        return (std::isinf)(x);
+    }
+    template<class T>
+    inline bool isinf_impl(T x, generic_tag<true> const&)
+    {
+        (void)x;
+        return std::numeric_limits<T>::has_infinity
+            && ( x == std::numeric_limits<T>::infinity()
+                 || x == -std::numeric_limits<T>::infinity());
+    }
+    template<class T>
+    inline bool isinf_impl(T x, generic_tag<false> const&)
+    {
+        (void)x;
+        return false;
+    }
+    template<class T>
+    inline bool isinf_impl(T x, ieee_copy_all_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent | traits::significand;
+        return a == traits::exponent;
+    }
+    template<class T>
+    inline bool isinf_impl(T x, ieee_copy_leading_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent | traits::significand;
+        if(a != traits::exponent)
+            return false;
+        traits::set_bits(x,0);
+        return x == 0;
+    }
+}
+template<class T>
+inline bool (isinf)(T x)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::isinf_impl(x, method());
+}
+namespace detail {
+    template<class T>
+    inline bool isnan_impl(T x, native_tag const&)
+    {
+        return (std::isnan)(x);
+    }
+    template<class T>
+    inline bool isnan_impl(T x, generic_tag<true> const&)
+    {
+        return std::numeric_limits<T>::has_infinity
+            ? !(x <= std::numeric_limits<T>::infinity())
+            : x != x;
+    }
+    template<class T>
+    inline bool isnan_impl(T x, generic_tag<false> const&)
+    {
+        (void)x;
+        return false;
+    }
+    template<class T>
+    inline bool isnan_impl(T x, ieee_copy_all_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent | traits::significand;
+        return a > traits::exponent;
+    }
+    template<class T>
+    inline bool isnan_impl(T x, ieee_copy_leading_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a &= traits::exponent | traits::significand;
+        if(a < traits::exponent)
+            return false;
+        a &= traits::significand;
+        traits::set_bits(x,a);
+        return x != 0;
+    }
+}
+template<class T> bool (isnan)(T x)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::isnan_impl(x, method());
+}
+}
+}
+namespace boost{ namespace math{
+namespace detail {
+    template<class T>
+    inline int signbit_impl(T x, native_tag const&)
+    {
+        return (std::signbit)(x);
+    }
+    template<class T>
+    inline int signbit_impl(T x, generic_tag<true> const&)
+    {
+        return x < 0;
+    }
+    template<class T>
+    inline int signbit_impl(T x, generic_tag<false> const&)
+    {
+        return x < 0;
+    }
+    template<class T>
+    inline int signbit_impl(T x, ieee_copy_all_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        return a & traits::sign ? 1 : 0;
+    }
+    template<class T>
+    inline int signbit_impl(T x, ieee_copy_leading_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        return a & traits::sign ? 1 : 0;
+    }
+    template<class T>
+    inline T (changesign_impl)(T x, generic_tag<true> const&)
+    {
+        return -x;
+    }
+    template<class T>
+    inline T (changesign_impl)(T x, generic_tag<false> const&)
+    {
+        return -x;
+    }
+    template<class T>
+    inline T changesign_impl(T x, ieee_copy_all_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::sign_change_type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a ^= traits::sign;
+        traits::set_bits(x,a);
+        return x;
+    }
+    template<class T>
+    inline T (changesign_impl)(T x, ieee_copy_leading_bits_tag const&)
+    {
+        typedef typename fp_traits<T>::sign_change_type traits;
+        typename traits::bits a;
+        traits::get_bits(x,a);
+        a ^= traits::sign;
+        traits::set_bits(x,a);
+        return x;
+    }
+}
+template<class T> int (signbit)(T x)
+{
+   typedef typename detail::fp_traits<T>::type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::signbit_impl(x, method());
+}
+template <class T>
+inline int sign (const T& z)
+{
+   return (z == 0) ? 0 : (boost::math::signbit)(z) ? -1 : 1;
+}
+template<class T> T (changesign)(const T& x)
+{
+   typedef typename detail::fp_traits<T>::sign_change_type traits;
+   typedef typename traits::method method;
+   typedef typename boost::is_floating_point<T>::type fp_tag;
+   return detail::changesign_impl(x, method());
+}
+template <class T>
+inline T copysign (const T& x, const T& y)
+{
+   using std::abs; using std::acos; using std::cos; using std::fmod; using std::modf; using std::tan; using std::asin; using std::cosh; using std::frexp; using std::pow; using std::tanh; using std::atan; using std::exp; using std::ldexp; using std::sin; using std::atan2; using std::fabs; using std::log; using std::sinh; using std::ceil; using std::floor; using std::log10; using std::sqrt; using boost::math::round; using boost::math::iround; using boost::math::lround; using boost::math::trunc; using boost::math::itrunc; using boost::math::ltrunc; using boost::math::modf;
+   return (boost::math::signbit)(x) != (boost::math::signbit)(y) ? (boost::math::changesign)(x) : x;
+}
+}
+}
+namespace boost { namespace spirit { namespace detail
+{
+    template<typename T>
+    inline bool (signbit)(T x)
+    {
+        return (boost::math::signbit)(x) ? true : false;
+    }
+    template<typename T>
+    inline T (changesign)(T x)
+    {
+        return -x;
+    }
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    using spirit::traits::pow10;
+    template <typename T>
+    inline void
+    scale(int exp, T& n)
+    {
+        if (exp >= 0)
+        {
+            n *= pow10<T>(exp);
+        }
+        else
+        {
+            if (exp < std::numeric_limits<T>::min_exponent10)
+            {
+                n /= pow10<T>(-std::numeric_limits<T>::min_exponent10);
+                n /= pow10<T>(-exp + std::numeric_limits<T>::min_exponent10);
+            }
+            else
+            {
+                n /= pow10<T>(-exp);
+            }
+        }
+    }
+    inline void
+    scale(int , unused_type )
+    {
+    }
+    template <typename T>
+    inline void
+    scale(int exp, int frac, T& n)
+    {
+        scale(exp - frac, n);
+    }
+    inline void
+    scale(int , int , unused_type )
+    {
+    }
+    inline float
+    negate(bool neg, float n)
+    {
+        return neg ? spirit::detail::changesign(n) : n;
+    }
+    inline double
+    negate(bool neg, double n)
+    {
+        return neg ? spirit::detail::changesign(n) : n;
+    }
+    inline long double
+    negate(bool neg, long double n)
+    {
+        return neg ? spirit::detail::changesign(n) : n;
+    }
+    template <typename T>
+    inline T
+    negate(bool neg, T const& n)
+    {
+        return neg ? -n : n;
+    }
+    inline unused_type
+    negate(bool , unused_type n)
+    {
+        return n;
+    }
+    template <typename T>
+    inline bool
+    is_equal_to_one(T const& value)
+    {
+        return value == 1.0;
+    }
+    inline bool
+    is_equal_to_one(unused_type)
+    {
+        return false;
+    }
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename T, typename RealPolicies>
+    struct real_impl
+    {
+        template <typename Iterator, typename Attribute>
+        static bool
+        parse(Iterator& first, Iterator const& last, Attribute& attr,
+            RealPolicies const& p)
+        {
+            if (first == last)
+                return false;
+            Iterator save = first;
+            bool neg = p.parse_sign(first, last);
+            T n = 0;
+            bool got_a_number = p.parse_n(first, last, n);
+            if (!got_a_number)
+            {
+                if (p.parse_nan(first, last, n) ||
+                    p.parse_inf(first, last, n))
+                {
+                    traits::assign_to(traits::negate(neg, n), attr);
+                    return true;
+                }
+                if (!p.allow_leading_dot)
+                {
+                    first = save;
+                    return false;
+                }
+            }
+            bool e_hit = false;
+            int frac_digits = 0;
+            if (p.parse_dot(first, last))
+            {
+                Iterator savef = first;
+                if (p.parse_frac_n(first, last, n))
+                {
+                    if (!is_same<T, unused_type>::value)
+                        frac_digits =
+                            static_cast<int>(std::distance(savef, first));
+                }
+                else if (!got_a_number || !p.allow_trailing_dot)
+                {
+                    first = save;
+                    return false;
+                }
+                e_hit = p.parse_exp(first, last);
+            }
+            else
+            {
+                if (!got_a_number)
+                {
+                    first = save;
+                    return false;
+                }
+                e_hit = p.parse_exp(first, last);
+                if (p.expect_dot && !e_hit)
+                {
+                    first = save;
+                    return false;
+                }
+            }
+            if (e_hit)
+            {
+                int exp = 0;
+                if (p.parse_exp_n(first, last, exp))
+                {
+                    traits::scale(exp, frac_digits, n);
+                }
+                else
+                {
+                    first = save;
+                    return false;
+                }
+            }
+            else if (frac_digits)
+            {
+                traits::scale(-frac_digits, n);
+            }
+            else if (traits::is_equal_to_one(n))
+            {
+                if (p.parse_nan(first, last, n) ||
+                    p.parse_inf(first, last, n))
+                {
+                    traits::assign_to(traits::negate(neg, n), attr);
+                    return true;
+                }
+            }
+            traits::assign_to(traits::negate(neg, n), attr);
+            return true;
+        }
+    };
+}}}}
+namespace boost { namespace spirit
+{
+    namespace qi
+    {
+        template <typename T>
+        struct real_policies;
+        template <typename T = double, typename Policies = real_policies<T> >
+        struct real_parser
+          : spirit::terminal<tag::stateful_tag<Policies, tag::double_, T> >
+        {
+            typedef tag::stateful_tag<Policies, tag::double_, T> tag_type;
+            real_parser() {}
+            real_parser(Policies const& p)
+              : spirit::terminal<tag_type>(p) {}
+        };
+    }
+    template <>
+    struct use_terminal<qi::domain, tag::float_>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::double_>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::long_double>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, float> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, double> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::lit, fusion::vector1<A0> >
+        , typename enable_if<is_same<A0, long double> >::type>
+      : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::float_, fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::double_, fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<tag::long_double, fusion::vector1<A0> >
+    > : mpl::true_ {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::float_, 1>
+      : mpl::true_ {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::double_, 1>
+      : mpl::true_ {};
+    template <>
+    struct use_lazy_terminal<qi::domain, tag::long_double, 1>
+      : mpl::true_ {};
+    template <typename T, typename Policies>
+    struct use_terminal<qi::domain
+        , tag::stateful_tag<Policies, tag::double_, T> >
+      : mpl::true_ {};
+    template <typename T, typename Policies, typename A0>
+    struct use_terminal<qi::domain
+        , terminal_ex<tag::stateful_tag<Policies, tag::double_, T>
+        , fusion::vector1<A0> > >
+      : mpl::true_ {};
+    template <typename T, typename Policies>
+    struct use_lazy_terminal<
+        qi::domain
+      , tag::stateful_tag<Policies, tag::double_, T>
+      , 1
+    > : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::float_;
+    using spirit::double_;
+    using spirit::long_double;
+    using spirit::lit;
+    using spirit::float_type;
+    using spirit::double_type;
+    using spirit::long_double_type;
+    using spirit::lit_type;
+    template <typename T, typename RealPolicies = real_policies<T> >
+    struct any_real_parser
+      : primitive_parser<any_real_parser<T, RealPolicies> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context, typename Skipper>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , T& attr) const
+        {
+            typedef detail::real_impl<T, RealPolicies> extract;
+            qi::skip_over(first, last, skipper);
+            return extract::parse(first, last, attr, RealPolicies());
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            T attr_;
+            if (parse(first, last, context, skipper, attr_))
+            {
+                traits::assign_to(attr_, attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("real");
+        }
+    };
+    template <typename T, typename RealPolicies = real_policies<T>
+            , bool no_attribute = true>
+    struct literal_real_parser
+      : primitive_parser<literal_real_parser<T, RealPolicies, no_attribute> >
+    {
+        template <typename Value>
+        literal_real_parser(Value const& n) : n_(n) {}
+        template <typename Context, typename Iterator>
+        struct attribute
+          : mpl::if_c<no_attribute, unused_type, T>
+        {};
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::real_impl<T, RealPolicies> extract;
+            qi::skip_over(first, last, skipper);
+            Iterator save = first;
+            T attr_;
+            if (extract::parse(first, last, attr_, RealPolicies()) &&
+                (attr_ == n_))
+            {
+                traits::assign_to(attr_, attr);
+                return true;
+            }
+            first = save;
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("real");
+        }
+        T n_;
+    };
+    template <typename T, typename Policies = real_policies<T> >
+    struct make_real
+    {
+        typedef any_real_parser<T, Policies> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename T, typename Policies = real_policies<T> >
+    struct make_direct_real
+    {
+        typedef literal_real_parser<T, Policies, false> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(T(fusion::at_c<0>(term.args)));
+        }
+    };
+    template <typename T, typename Policies = real_policies<T> >
+    struct make_literal_real
+    {
+        typedef literal_real_parser<T, Policies> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return result_type(fusion::at_c<0>(term.args));
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, float> >::type>
+      : make_literal_real<float> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, double> >::type>
+      : make_literal_real<double> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+          terminal_ex<tag::lit, fusion::vector1<A0> >
+        , Modifiers, typename enable_if<is_same<A0, long double> >::type>
+      : make_literal_real<long double> {};
+    template <typename T, typename Policies, typename Modifiers>
+    struct make_primitive<
+        tag::stateful_tag<Policies, tag::double_, T>, Modifiers>
+      : make_real<T, Policies> {};
+    template <typename T, typename Policies, typename A0, typename Modifiers>
+    struct make_primitive<
+        terminal_ex<tag::stateful_tag<Policies, tag::double_, T>
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_real<T, Policies> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::float_, Modifiers>
+      : make_real<float> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::float_
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_real<float> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::double_, Modifiers>
+      : make_real<double> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::double_
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_real<double> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::long_double, Modifiers>
+      : make_real<long double> {};
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::long_double
+      , fusion::vector1<A0> >, Modifiers>
+      : make_direct_real<long double> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::shift_right>
+      : mpl::true_ {};
+    template <>
+    struct flatten_tree<qi::domain, proto::tag::shift_right>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Elements>
+    struct sequence : sequence_base<sequence<Elements>, Elements>
+    {
+        friend struct sequence_base<sequence<Elements>, Elements>;
+        sequence(Elements const& elements)
+          : sequence_base<sequence<Elements>, Elements>(elements) {}
+    private:
+        template <typename Iterator, typename Context, typename Skipper>
+        static detail::fail_function<Iterator, Context, Skipper>
+        fail_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+        {
+            return detail::fail_function<Iterator, Context, Skipper>
+                (first, last, context, skipper);
+        }
+        std::string id() const { return "sequence"; }
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::shift_right, Elements, Modifiers>
+      : make_nary_composite<Elements, sequence>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Elements>
+    struct has_semantic_action<qi::sequence<Elements> >
+      : nary_has_semantic_action<Elements> {};
+    template <typename Elements, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::sequence<Elements>, Attribute, Context
+          , Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Variant, typename Expected>
+    struct find_substitute
+    {
+        typedef Variant variant_type;
+        typedef typename variant_type::types types;
+        typedef typename mpl::end<types>::type end;
+        typedef typename
+            mpl::find_if<types, is_same<mpl::_1, Expected> >::type
+        iter_1;
+        typedef typename
+            mpl::eval_if<
+                is_same<iter_1, end>,
+                mpl::find_if<types, traits::is_substitute<mpl::_1, Expected> >,
+                mpl::identity<iter_1>
+            >::type
+        iter;
+        typedef typename
+            mpl::eval_if<
+                is_same<iter, end>,
+                mpl::identity<Expected>,
+                mpl::deref<iter>
+            >::type
+        type;
+    };
+    template <typename Iterator, typename Context, typename Skipper,
+        typename Attribute>
+    struct alternative_function
+    {
+        alternative_function(
+            Iterator& first, Iterator const& last, Context& context,
+            Skipper const& skipper, Attribute& attr)
+          : first(first), last(last), context(context), skipper(skipper),
+            attr(attr)
+        {
+        }
+        template <typename Component>
+        bool call(Component const& component, mpl::true_) const
+        {
+            return component.parse(first, last, context, skipper, attr);
+        }
+        template <typename Component>
+        bool call_optional_or_variant(Component const& component, mpl::true_) const
+        {
+            typedef typename
+                traits::attribute_of<Component, Context, Iterator>::type
+            expected_type;
+            typename mpl::if_<
+                is_same<expected_type, unused_type>,
+                unused_type,
+                typename Attribute::value_type>::type
+            val;
+            if (component.parse(first, last, context, skipper, val))
+            {
+                traits::assign_to(val, attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Component>
+        bool call_variant(Component const& component, mpl::false_) const
+        {
+            typename
+                find_substitute<Attribute,
+                    typename traits::attribute_of<Component, Context, Iterator>::type
+                >::type
+            val;
+            if (component.parse(first, last, context, skipper, val))
+            {
+                traits::assign_to(val, attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Component>
+        bool call_variant(Component const& component, mpl::true_) const
+        {
+            return component.parse(first, last, context, skipper, attr);
+        }
+        template <typename Component>
+        bool call_optional_or_variant(Component const& component, mpl::false_) const
+        {
+            typedef typename
+                traits::attribute_of<Component, Context, Iterator>::type
+            expected;
+            return call_variant(component,
+                is_same<Attribute, expected>());
+        }
+        template <typename Component>
+        bool call(Component const& component, mpl::false_) const
+        {
+            return call_optional_or_variant(
+                component, spirit::traits::not_is_variant<Attribute, qi::domain>());
+        }
+        template <typename Component>
+        bool call_unused(Component const& component, mpl::true_) const
+        {
+            return call(component,
+                mpl::and_<
+                    spirit::traits::not_is_variant<Attribute, qi::domain>,
+                    spirit::traits::not_is_optional<Attribute, qi::domain>
+                >());
+        }
+        template <typename Component>
+        bool call_unused(Component const& component, mpl::false_) const
+        {
+            return component.parse(first, last, context, skipper, unused);
+        }
+        template <typename Component>
+        bool operator()(Component const& component) const
+        {
+            typedef typename traits::not_is_unused<
+                typename traits::attribute_of<Component, Context, Iterator>::type
+            >::type predicate;
+            return call_unused(component, predicate());
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+        Attribute& attr;
+    private:
+        alternative_function& operator= (alternative_function const&);
+    };
+    template <typename Iterator, typename Context, typename Skipper>
+    struct alternative_function<Iterator, Context, Skipper, unused_type const>
+    {
+        alternative_function(
+            Iterator& first, Iterator const& last, Context& context,
+            Skipper const& skipper, unused_type)
+          : first(first), last(last), context(context), skipper(skipper)
+        {
+        }
+        template <typename Component>
+        bool operator()(Component const& component)
+        {
+            return component.parse(first, last, context, skipper,
+                unused);
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+    private:
+        alternative_function& operator= (alternative_function const&);
+    };
+}}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::bitwise_or>
+      : mpl::true_ {};
+    template <>
+    struct flatten_tree<qi::domain, proto::tag::bitwise_or>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Elements>
+    struct alternative : nary_parser<alternative<Elements> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename traits::build_attribute_sequence<
+                Elements, Context, traits::alternative_attribute_transform
+              , Iterator, qi::domain
+            >::type all_attributes;
+            typedef typename
+                traits::build_variant<all_attributes>::type
+            type;
+        };
+        alternative(Elements const& elements)
+          : elements(elements) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            detail::alternative_function<Iterator, Context, Skipper, Attribute>
+                f(first, last, context, skipper, attr);
+            return fusion::any(elements, f);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            info result("alternative");
+            fusion::for_each(elements,
+                spirit::detail::what_function<Context>(result, context));
+            return result;
+        }
+        Elements elements;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::bitwise_or, Elements, Modifiers>
+      : make_nary_composite<Elements, alternative>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Elements>
+    struct has_semantic_action<qi::alternative<Elements> >
+      : nary_has_semantic_action<Elements> {};
+    template <typename Elements, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::alternative<Elements>, Attribute, Context
+      , Iterator>
+      : nary_handles_container<Elements, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Iterator, typename Context, typename Skipper>
+    struct pass_function
+    {
+        pass_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+          : first(first)
+          , last(last)
+          , context(context)
+          , skipper(skipper)
+        {
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, Attribute& attr)
+        {
+            return component.parse(first, last, context, skipper, attr);
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, boost::optional<Attribute>& attr)
+        {
+            Attribute val;
+            if (component.parse(first, last, context, skipper, val))
+            {
+                attr = val;
+                return true;
+            }
+            return false;
+        }
+        template <typename Component>
+        bool operator()(Component const& component)
+        {
+            return component.parse(first, last, context, skipper, unused);
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+    private:
+        pass_function& operator= (pass_function const&);
+    };
+}}}}
+namespace boost { namespace spirit
+{
+    namespace detail
+    {
+        template <typename First1, typename Last, typename First2, typename F>
+        inline bool
+        any_ns(First1 const&, First2 const&, Last const&, F const&, mpl::true_)
+        {
+            return false;
+        }
+        template <typename First1, typename Last, typename First2, typename F>
+        inline bool
+        any_ns(First1 const& first1, First2 const& first2, Last const& last, F& f, mpl::false_)
+        {
+            return (0 != (f(*first1, *first2) |
+                detail::any_ns(
+                    fusion::next(first1)
+                  , fusion::next(first2)
+                  , last
+                  , f
+                  , fusion::result_of::equal_to<
+                        typename fusion::result_of::next<First1>::type, Last>())));
+        }
+        template <typename First, typename Last, typename F>
+        inline bool
+        any_ns(First const&, Last const&, F const&, mpl::true_)
+        {
+            return false;
+        }
+        template <typename First, typename Last, typename F>
+        inline bool
+        any_ns(First const& first, Last const& last, F& f, mpl::false_)
+        {
+            return (0 != (f(*first) |
+                detail::any_ns(
+                    fusion::next(first)
+                  , last
+                  , f
+                  , fusion::result_of::equal_to<
+                        typename fusion::result_of::next<First>::type, Last>())));
+        }
+    }
+    template <typename Sequence1, typename Sequence2, typename F>
+    inline bool
+    any_ns(Sequence1 const& seq1, Sequence2& seq2, F f)
+    {
+        return detail::any_ns(
+                fusion::begin(seq1)
+              , fusion::begin(seq2)
+              , fusion::end(seq1)
+              , f
+              , fusion::result_of::equal_to<
+                    typename fusion::result_of::begin<Sequence1>::type
+                  , typename fusion::result_of::end<Sequence1>::type>());
+    }
+    template <typename Sequence, typename F>
+    inline bool
+    any_ns(Sequence const& seq, unused_type, F f)
+    {
+        return detail::any_ns(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , fusion::result_of::equal_to<
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type>());
+    }
+}}
+namespace boost { namespace spirit
+{
+    namespace detail
+    {
+        template <
+            typename Pred, typename First1, typename Last1, typename First2
+          , typename Last2, typename F
+        >
+        inline bool
+        any_if_ns(First1 const&, First2 const&, Last1 const&, Last2 const&
+          , F const&, mpl::true_)
+        {
+            return false;
+        }
+        template <
+            typename Pred, typename First1, typename Last1, typename First2
+          , typename Last2, typename F
+        >
+        inline bool
+        any_if_ns(First1 const& first1, First2 const& first2
+          , Last1 const& last1, Last2 const& last2, F& f, mpl::false_)
+        {
+            return (0 != (f(*first1, attribute_value<Pred, First1, Last2>(first2)) |
+                detail::any_if_ns<Pred>(
+                    fusion::next(first1)
+                  , attribute_next<Pred, First1, Last2>(first2)
+                  , last1, last2
+                  , f
+                  , fusion::result_of::equal_to<
+                        typename fusion::result_of::next<First1>::type, Last1>())));
+        }
+    }
+    template <typename Pred, typename Sequence1, typename Sequence2, typename F>
+    inline bool
+    any_if_ns(Sequence1 const& seq1, Sequence2& seq2, F f, Pred)
+    {
+        return detail::any_if_ns<Pred>(
+                fusion::begin(seq1), fusion::begin(seq2)
+              , fusion::end(seq1), fusion::end(seq2)
+              , f
+              , fusion::result_of::equal_to<
+                    typename fusion::result_of::begin<Sequence1>::type
+                  , typename fusion::result_of::end<Sequence1>::type>());
+    }
+    template <typename Pred, typename Sequence, typename F>
+    inline bool
+    any_if_ns(Sequence const& seq, unused_type const, F f, Pred)
+    {
+        return detail::any_ns(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , fusion::result_of::equal_to<
+                    typename fusion::result_of::begin<Sequence>::type
+                  , typename fusion::result_of::end<Sequence>::type>());
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::logical_or>
+      : mpl::true_ {};
+    template <>
+    struct flatten_tree<qi::domain, proto::tag::logical_or>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Elements>
+    struct sequential_or : nary_parser<sequential_or<Elements> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename traits::build_attribute_sequence<
+                Elements, Context, traits::sequential_or_attribute_transform
+              , Iterator, qi::domain
+            >::type all_attributes;
+            typedef typename
+                traits::build_fusion_vector<all_attributes>::type
+            type;
+        };
+        sequential_or(Elements const& elements)
+          : elements(elements) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr_) const
+        {
+            typedef traits::attribute_not_unused<Context, Iterator> predicate;
+            detail::pass_function<Iterator, Context, Skipper>
+                f(first, last, context, skipper);
+            typename traits::wrap_if_not_tuple<Attribute>::type attr(attr_);
+            return spirit::any_if_ns(elements, attr, f, predicate());
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            info result("sequential-or");
+            fusion::for_each(elements,
+                spirit::detail::what_function<Context>(result, context));
+            return result;
+        }
+        Elements elements;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::logical_or, Elements, Modifiers>
+      : make_nary_composite<Elements, sequential_or>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Elements, typename Attribute>
+    struct pass_attribute<qi::sequential_or<Elements>, Attribute>
+      : wrap_if_not_tuple<Attribute> {};
+    template <typename Elements>
+    struct has_semantic_action<qi::sequential_or<Elements> >
+      : nary_has_semantic_action<Elements> {};
+    template <typename Elements, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::sequential_or<Elements>, Attribute, Context
+      , Iterator>
+      : nary_handles_container<Elements, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Iterator, typename Context, typename Skipper>
+    struct permute_function
+    {
+        permute_function(
+            Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper)
+          : first(first)
+          , last(last)
+          , context(context)
+          , skipper(skipper)
+        {
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, Attribute& attr)
+        {
+            if (!*taken && component.parse(first, last, context, skipper, attr))
+            {
+                *taken = true;
+                ++taken;
+                return true;
+            }
+            ++taken;
+            return false;
+        }
+        template <typename Component, typename Attribute>
+        bool operator()(Component const& component, boost::optional<Attribute>& attr)
+        {
+            Attribute val;
+            if (!*taken && component.parse(first, last, context, skipper, val))
+            {
+                attr = val;
+                *taken = true;
+                ++taken;
+                return true;
+            }
+            ++taken;
+            return false;
+        }
+        template <typename Component>
+        bool operator()(Component const& component)
+        {
+            if (!*taken && component.parse(first, last, context, skipper, unused))
+            {
+                *taken = true;
+                ++taken;
+                return true;
+            }
+            ++taken;
+            return false;
+        }
+        Iterator& first;
+        Iterator const& last;
+        Context& context;
+        Skipper const& skipper;
+        bool* taken;
+    private:
+        permute_function& operator= (permute_function const&);
+    };
+}}}}
+namespace boost {
+    template<class T, std::size_t N>
+    class array {
+      public:
+        T elems[N];
+      public:
+        typedef T value_type;
+        typedef T* iterator;
+        typedef const T* const_iterator;
+        typedef T& reference;
+        typedef const T& const_reference;
+        typedef std::size_t size_type;
+        typedef std::ptrdiff_t difference_type;
+        iterator begin() { return elems; }
+        const_iterator begin() const { return elems; }
+        const_iterator cbegin() const { return elems; }
+        iterator end() { return elems+N; }
+        const_iterator end() const { return elems+N; }
+        const_iterator cend() const { return elems+N; }
+        typedef std::reverse_iterator<iterator> reverse_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+        reverse_iterator rbegin() { return reverse_iterator(end()); }
+        const_reverse_iterator rbegin() const {
+            return const_reverse_iterator(end());
+        }
+        const_reverse_iterator crbegin() const {
+            return const_reverse_iterator(end());
+        }
+        reverse_iterator rend() { return reverse_iterator(begin()); }
+        const_reverse_iterator rend() const {
+            return const_reverse_iterator(begin());
+        }
+        const_reverse_iterator crend() const {
+            return const_reverse_iterator(begin());
+        }
+        reference operator[](size_type i)
+        {
+            (static_cast<void> (0));
+            return elems[i];
+        }
+        const_reference operator[](size_type i) const
+        {
+            (static_cast<void> (0));
+            return elems[i];
+        }
+        reference at(size_type i) { rangecheck(i); return elems[i]; }
+        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
+        reference front()
+        {
+            return elems[0];
+        }
+        const_reference front() const
+        {
+            return elems[0];
+        }
+        reference back()
+        {
+            return elems[N-1];
+        }
+        const_reference back() const
+        {
+            return elems[N-1];
+        }
+        static size_type size() { return N; }
+        static bool empty() { return false; }
+        static size_type max_size() { return N; }
+        enum { static_size = N };
+        void swap (array<T,N>& y) {
+            for (size_type i = 0; i < N; ++i)
+                boost::swap(elems[i],y.elems[i]);
+        }
+        const T* data() const { return elems; }
+        T* data() { return elems; }
+        T* c_array() { return elems; }
+        template <typename T2>
+        array<T,N>& operator= (const array<T2,N>& rhs) {
+            std::copy(rhs.begin(),rhs.end(), begin());
+            return *this;
+        }
+        void assign (const T& value) { fill ( value ); }
+        void fill (const T& value)
+        {
+            std::fill_n(begin(),size(),value);
+        }
+        static void rangecheck (size_type i) {
+            if (i >= size()) {
+                std::out_of_range e("array<>: index out of range");
+                boost::throw_exception(e);
+            }
+        }
+    };
+    template< class T >
+    class array< T, 0 > {
+      public:
+        typedef T value_type;
+        typedef T* iterator;
+        typedef const T* const_iterator;
+        typedef T& reference;
+        typedef const T& const_reference;
+        typedef std::size_t size_type;
+        typedef std::ptrdiff_t difference_type;
+        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
+        const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
+        const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
+        iterator end() { return begin(); }
+        const_iterator end() const { return begin(); }
+        const_iterator cend() const { return cbegin(); }
+        typedef std::reverse_iterator<iterator> reverse_iterator;
+        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+        reverse_iterator rbegin() { return reverse_iterator(end()); }
+        const_reverse_iterator rbegin() const {
+            return const_reverse_iterator(end());
+        }
+        const_reverse_iterator crbegin() const {
+            return const_reverse_iterator(end());
+        }
+        reverse_iterator rend() { return reverse_iterator(begin()); }
+        const_reverse_iterator rend() const {
+            return const_reverse_iterator(begin());
+        }
+        const_reverse_iterator crend() const {
+            return const_reverse_iterator(begin());
+        }
+        reference operator[](size_type )
+        {
+            return failed_rangecheck();
+        }
+        const_reference operator[](size_type ) const
+        {
+            return failed_rangecheck();
+        }
+        reference at(size_type ) { return failed_rangecheck(); }
+        const_reference at(size_type ) const { return failed_rangecheck(); }
+        reference front()
+        {
+            return failed_rangecheck();
+        }
+        const_reference front() const
+        {
+            return failed_rangecheck();
+        }
+        reference back()
+        {
+            return failed_rangecheck();
+        }
+        const_reference back() const
+        {
+            return failed_rangecheck();
+        }
+        static size_type size() { return 0; }
+        static bool empty() { return true; }
+        static size_type max_size() { return 0; }
+        enum { static_size = 0 };
+        void swap (array<T,0>& ) {
+        }
+        const T* data() const { return 0; }
+        T* data() { return 0; }
+        T* c_array() { return 0; }
+        template <typename T2>
+        array<T,0>& operator= (const array<T2,0>& ) {
+            return *this;
+        }
+        void assign (const T& value) { fill ( value ); }
+        void fill (const T& ) {}
+        static reference failed_rangecheck () {
+                std::out_of_range e("attempt to access element of an empty array");
+                boost::throw_exception(e);
+                static T placeholder;
+                return placeholder;
+            }
+    };
+    template<class T, std::size_t N>
+    bool operator== (const array<T,N>& x, const array<T,N>& y) {
+        return std::equal(x.begin(), x.end(), y.begin());
+    }
+    template<class T, std::size_t N>
+    bool operator< (const array<T,N>& x, const array<T,N>& y) {
+        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+    }
+    template<class T, std::size_t N>
+    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
+        return !(x==y);
+    }
+    template<class T, std::size_t N>
+    bool operator> (const array<T,N>& x, const array<T,N>& y) {
+        return y<x;
+    }
+    template<class T, std::size_t N>
+    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
+        return !(y<x);
+    }
+    template<class T, std::size_t N>
+    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
+        return !(x<y);
+    }
+    template<class T, std::size_t N>
+    inline void swap (array<T,N>& x, array<T,N>& y) {
+        x.swap(y);
+    }
+    template <typename T, std::size_t N>
+    T(&get_c_array(boost::array<T,N>& arg))[N]
+    {
+        return arg.elems;
+    }
+    template <typename T, std::size_t N>
+    const T(&get_c_array(const boost::array<T,N>& arg))[N]
+    {
+        return arg.elems;
+    }
+}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::bitwise_xor>
+      : mpl::true_ {};
+    template <>
+    struct flatten_tree<qi::domain, proto::tag::bitwise_xor>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Elements>
+    struct permutation : nary_parser<permutation<Elements> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename traits::build_attribute_sequence<
+                Elements, Context, traits::permutation_attribute_transform
+              , Iterator, qi::domain
+            >::type all_attributes;
+            typedef typename
+                traits::build_fusion_vector<all_attributes>::type
+            type;
+        };
+        permutation(Elements const& elements)
+          : elements(elements) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr_) const
+        {
+            typedef traits::attribute_not_unused<Context, Iterator> predicate;
+            detail::permute_function<Iterator, Context, Skipper>
+                f(first, last, context, skipper);
+            boost::array<bool, fusion::result_of::size<Elements>::value> flags;
+            if (bool _foreach_is_rvalue79 = false) {} else if (boost::foreach_detail_::auto_any_t _foreach_col79 = boost::foreach_detail_::contain( (true ? boost::foreach_detail_::make_probe((flags), _foreach_is_rvalue79) : (flags)) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(flags) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(flags))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue79)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_cur79 = boost::foreach_detail_::begin( _foreach_col79 , (true ? 0 : boost::foreach_detail_::encode_type(flags, boost::foreach_detail_::is_const_(flags))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(flags) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(flags))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue79)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_end79 = boost::foreach_detail_::end( _foreach_col79 , (true ? 0 : boost::foreach_detail_::encode_type(flags, boost::foreach_detail_::is_const_(flags))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(flags) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(flags))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(flags) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue79)))) {} else for (bool _foreach_continue79 = true; _foreach_continue79 && !boost::foreach_detail_::done( _foreach_cur79 , _foreach_end79 , (true ? 0 : boost::foreach_detail_::encode_type(flags, boost::foreach_detail_::is_const_(flags)))); _foreach_continue79 ? boost::foreach_detail_::next( _foreach_cur79 , (true ? 0 : boost::foreach_detail_::encode_type(flags, boost::foreach_detail_::is_const_(flags)))) : (void)0) if (boost::foreach_detail_::set_false(_foreach_continue79)) {} else for (bool& taken = boost::foreach_detail_::deref( _foreach_cur79 , (true ? 0 : boost::foreach_detail_::encode_type(flags, boost::foreach_detail_::is_const_(flags)))); !_foreach_continue79; _foreach_continue79 = true)
+            {
+                taken = false;
+            }
+            typename traits::wrap_if_not_tuple<Attribute>::type attr(attr_);
+            bool result = false;
+            f.taken = flags.begin();
+            while (spirit::any_if_ns(elements, attr, f, predicate()))
+            {
+                f.taken = flags.begin();
+                result = true;
+            }
+            return result;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            info result("permutation");
+            fusion::for_each(elements,
+                spirit::detail::what_function<Context>(result, context));
+            return result;
+        }
+        Elements elements;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::bitwise_xor, Elements, Modifiers>
+      : make_nary_composite<Elements, permutation>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Elements, typename Attribute>
+    struct pass_attribute<qi::permutation<Elements>, Attribute>
+      : wrap_if_not_tuple<Attribute> {};
+    template <typename Elements>
+    struct has_semantic_action<qi::permutation<Elements> >
+      : nary_has_semantic_action<Elements> {};
+    template <typename Elements, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::permutation<Elements>, Attribute, Context
+      , Iterator>
+      : nary_handles_container<Elements, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::minus>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Left, typename Right>
+    struct difference : binary_parser<difference<Left, Right> >
+    {
+        typedef Left left_type;
+        typedef Right right_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::attribute_of<left_type, Context, Iterator>::type
+            type;
+        };
+        difference(Left const& left, Right const& right)
+          : left(left), right(right) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            Iterator start = first;
+            if (right.parse(first, last, context, skipper, unused))
+            {
+                first = start;
+                return false;
+            }
+            return left.parse(first, last, context, skipper, attr);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("difference",
+                std::make_pair(left.what(context), right.what(context)));
+        }
+        Left left;
+        Right right;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::minus, Elements, Modifiers>
+      : make_binary_composite<Elements, difference>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Left, typename Right>
+    struct has_semantic_action<qi::difference<Left, Right> >
+      : binary_has_semantic_action<Left, Right> {};
+    template <typename Left, typename Right, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::difference<Left, Right>, Attribute, Context
+      , Iterator>
+      : binary_handles_container<Left, Right, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::modulus>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Left, typename Right>
+    struct list : binary_parser<list<Left, Right> >
+    {
+        typedef Left left_type;
+        typedef Right right_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::build_std_vector<
+                    typename traits::
+                        attribute_of<Left, Context, Iterator>::type
+                >::type
+            type;
+        };
+        list(Left const& left, Right const& right)
+          : left(left), right(right) {}
+        template <typename F>
+        bool parse_container(F f) const
+        {
+            if (f (left))
+                return false;
+            typename F::iterator_type save = f.f.first;
+            while (right.parse(f.f.first, f.f.last, f.f.context, f.f.skipper, unused)
+              && !f (left))
+            {
+                save = f.f.first;
+            }
+            f.f.first = save;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::fail_function<Iterator, Context, Skipper>
+                fail_function;
+            traits::make_container(attr);
+            Iterator iter = first;
+            fail_function f(iter, last, context, skipper);
+            if (!parse_container(detail::make_pass_container(f, attr)))
+                return false;
+            first = f.first;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("list",
+                std::make_pair(left.what(context), right.what(context)));
+        }
+        Left left;
+        Right right;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::modulus, Elements, Modifiers>
+      : make_binary_composite<Elements, list>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Left, typename Right>
+    struct has_semantic_action<qi::list<Left, Right> >
+      : binary_has_semantic_action<Left, Right> {};
+    template <typename Left, typename Right, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::list<Left, Right>, Attribute, Context
+          , Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::negate>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct optional : unary_parser<optional<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::build_optional<
+                    typename traits::
+                        attribute_of<Subject, Context, Iterator>::type
+                >::type
+            type;
+        };
+        optional(Subject const& subject)
+          : subject(subject) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse_impl(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr, mpl::false_) const
+        {
+            typename spirit::result_of::optional_value<Attribute>::type val =
+                typename spirit::result_of::optional_value<Attribute>::type();
+            if (subject.parse(first, last, context, skipper, val))
+            {
+                spirit::traits::assign_to(val, attr);
+            }
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse_impl(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr, mpl::true_) const
+        {
+            subject.parse(first, last, context, skipper, attr);
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef typename spirit::result_of::optional_value<Attribute>::type
+                attribute_type;
+            return parse_impl(first, last, context, skipper, attr
+              , traits::is_container<attribute_type>());
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("optional", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::negate, Elements, Modifiers>
+      : make_unary_composite<Elements, optional>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::optional<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::optional<Subject>, Attribute
+          , Context, Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::unary_plus>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct plus : unary_parser<plus<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename
+                traits::build_std_vector<
+                    typename traits::attribute_of<
+                        Subject, Context, Iterator>::type
+                >::type
+            type;
+        };
+        plus(Subject const& subject)
+          : subject(subject) {}
+        template <typename F>
+        bool parse_container(F f) const
+        {
+            if (f (subject))
+                return false;
+            while (!f (subject))
+                ;
+            return true;
+        }
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef detail::fail_function<Iterator, Context, Skipper>
+                fail_function;
+            traits::make_container(attr);
+            Iterator iter = first;
+            fail_function f(iter, last, context, skipper);
+            if (!parse_container(detail::make_pass_container(f, attr)))
+                return false;
+            first = f.first;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("plus", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::unary_plus, Elements, Modifiers>
+      : make_unary_composite<Elements, plus>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::plus<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::plus<Subject>, Attribute, Context
+          , Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::address_of>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct and_predicate : unary_parser<and_predicate<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        and_predicate(Subject const& subject)
+          : subject(subject) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& ) const
+        {
+            Iterator i = first;
+            return subject.parse(i, last, context, skipper, unused);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("and-predicate", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::address_of, Elements, Modifiers>
+      : make_unary_composite<Elements, and_predicate>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::and_predicate<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+      , typename Iterator>
+    struct handles_container<qi::and_predicate<Subject>, Attribute, Context
+      , Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_operator<qi::domain, proto::tag::logical_not>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Subject>
+    struct not_predicate : unary_parser<not_predicate<Subject> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef unused_type type;
+        };
+        not_predicate(Subject const& subject)
+          : subject(subject) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& ) const
+        {
+            Iterator i = first;
+            return !subject.parse(i, last, context, skipper, unused);
+        }
+        template <typename Context>
+        info what(Context& context) const
+        {
+            return info("not-predicate", subject.what(context));
+        }
+        Subject subject;
+    };
+    template <typename Elements, typename Modifiers>
+    struct make_composite<proto::tag::logical_not, Elements, Modifiers>
+      : make_unary_composite<Elements, not_predicate>
+    {};
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject>
+    struct has_semantic_action<qi::not_predicate<Subject> >
+      : unary_has_semantic_action<Subject> {};
+    template <typename Subject, typename Attribute, typename Context
+        , typename Iterator>
+    struct handles_container<qi::not_predicate<Subject>, Attribute
+        , Context, Iterator>
+      : unary_handles_container<Subject, Attribute, Context, Iterator> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1&
+        > vector_type;
+        vector_type attr ( attr0 , attr1);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1&
+        > vector_type;
+        vector_type attr ( attr0 , attr1);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7& , A8&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7& , A8&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8);
+    }
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check54;
+        struct error_invalid_expression; typedef struct error_invalid_expression59 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg59; enum { mpl_assertion_in_line_59 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg59::assert_arg() ) ) };
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7& , A8& , A9&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+    }
+    template <typename Iterator, typename Expr
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        Iterator first = first_;
+        return qi::parse(first, last, expr, attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(ForwardIterator<Iterator>)>::failed> boost_concept_check98;
+        struct error_invalid_expression; typedef struct error_invalid_expression104 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg104; enum { mpl_assertion_in_line_104 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg104::assert_arg() ) ) };
+        struct error_invalid_expression; typedef struct error_invalid_expression105 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg105; enum { mpl_assertion_in_line_105 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg105::assert_arg() ) ) };
+        typedef
+            typename result_of::compile<qi::domain, Skipper>::type
+        skipper_type;
+        skipper_type const skipper_ = compile<qi::domain>(skipper);
+        typedef fusion::vector<
+            A0& , A1& , A2& , A3& , A4& , A5& , A6& , A7& , A8& , A9&
+        > vector_type;
+        vector_type attr ( attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+        if (!compile<qi::domain>(expr).parse(
+                first, last, unused, skipper_, attr))
+            return false;
+        if (post_skip == skip_flag::postskip)
+            qi::skip_over(first, last, skipper_);
+        return true;
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , skip_flag::enum_type post_skip
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, post_skip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    phrase_parse(
+        Iterator& first
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+    }
+    template <typename Iterator, typename Expr, typename Skipper
+      , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    inline bool
+    phrase_parse(
+        Iterator const& first_
+      , Iterator last
+      , Expr const& expr
+      , Skipper const& skipper
+      , A0 & attr0 , A1 & attr1 , A2 & attr2 , A3 & attr3 , A4 & attr4 , A5 & attr5 , A6 & attr6 , A7 & attr7 , A8 & attr8 , A9 & attr9)
+    {
+        Iterator first = first_;
+        return qi::phrase_parse(first, last, expr, skipper, skip_flag::postskip
+          , attr0 , attr1 , attr2 , attr3 , attr4 , attr5 , attr6 , attr7 , attr8 , attr9);
+    }
+}}}
+namespace boost { namespace spirit
+{
+    template <typename T>
+    struct use_terminal<qi::domain, T
+      , typename enable_if<traits::is_string<T> >::type>
+      : mpl::true_ {};
+    template <typename CharEncoding, typename A0>
+    struct use_terminal<qi::domain
+      , terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector1<A0> >
+    > : traits::is_string<A0> {};
+    template <typename CharEncoding>
+    struct use_lazy_terminal<
+        qi::domain
+      , tag::char_code<tag::string, CharEncoding>
+      , 1
+    > : mpl::true_ {};
+    template <typename A0>
+    struct use_terminal<qi::domain
+          , terminal_ex<tag::lit, fusion::vector1<A0> >
+          , typename enable_if<traits::is_string<A0> >::type>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::lit;
+    using spirit::lit_type;
+    template <typename String, bool no_attribute>
+    struct literal_string
+      : primitive_parser<literal_string<String, no_attribute> >
+    {
+        typedef typename
+            remove_const<typename traits::char_type_of<String>::type>::type
+        char_type;
+        typedef std::basic_string<char_type> string_type;
+        literal_string(typename add_reference<String>::type str)
+          : str(str)
+        {}
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename mpl::if_c<
+                no_attribute, unused_type, string_type>::type
+            type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper, Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            return detail::string_parse(str, first, last, attr);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("literal-string", str);
+        }
+        String str;
+    private:
+        literal_string& operator= (literal_string const&);
+    };
+    template <typename String, bool no_attribute>
+    struct no_case_literal_string
+      : primitive_parser<no_case_literal_string<String, no_attribute> >
+    {
+        typedef typename
+            remove_const<typename traits::char_type_of<String>::type>::type
+        char_type;
+        typedef std::basic_string<char_type> string_type;
+        template <typename CharEncoding>
+        no_case_literal_string(char_type const* in, CharEncoding encoding)
+          : str_lo(in)
+          , str_hi(in)
+        {
+            typename string_type::iterator loi = str_lo.begin();
+            typename string_type::iterator hii = str_hi.begin();
+            for (; loi != str_lo.end(); ++loi, ++hii, ++in)
+            {
+                typedef typename CharEncoding::char_type encoded_char_type;
+                *loi = static_cast<char_type>(encoding.tolower(encoded_char_type(*loi)));
+                *hii = static_cast<char_type>(encoding.toupper(encoded_char_type(*hii)));
+            }
+        }
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef typename mpl::if_c<
+                no_attribute, unused_type, string_type>::type
+            type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper, Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            return detail::string_parse(str_lo, str_hi, first, last, attr);
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("no-case-literal-string", str_lo);
+        }
+        string_type str_lo, str_hi;
+    };
+    template <typename T, typename Modifiers>
+    struct make_primitive<T, Modifiers
+      , typename enable_if<traits::is_string<T> >::type>
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
+        typedef typename add_const<T>::type const_string;
+        typedef typename mpl::if_<
+            no_case
+          , no_case_literal_string<const_string, true>
+          , literal_string<const_string, true> >::type
+        result_type;
+        result_type operator()(
+            typename add_reference<const_string>::type str, unused_type) const
+        {
+            return op(str, no_case());
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::false_) const
+        {
+            return result_type(str);
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::true_) const
+        {
+            typename spirit::detail::get_encoding<Modifiers,
+                spirit::char_encoding::standard>::type encoding;
+            return result_type(traits::get_c_string(str), encoding);
+        }
+    };
+    template <typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<tag::lit, fusion::vector1<A0> >
+      , Modifiers
+      , typename enable_if<traits::is_string<A0> >::type>
+    {
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
+        typedef typename add_const<A0>::type const_string;
+        typedef typename mpl::if_<
+            no_case
+          , no_case_literal_string<const_string, true>
+          , literal_string<const_string, true> >::type
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return op(fusion::at_c<0>(term.args), no_case());
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::false_) const
+        {
+            return result_type(str);
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::true_) const
+        {
+            typedef typename traits::char_encoding_from_char<
+                typename traits::char_type_of<A0>::type>::type encoding_type;
+            typename spirit::detail::get_encoding<Modifiers,
+                encoding_type>::type encoding;
+            return result_type(traits::get_c_string(str), encoding);
+        }
+    };
+    template <typename CharEncoding, typename Modifiers, typename A0>
+    struct make_primitive<
+        terminal_ex<
+            tag::char_code<tag::string, CharEncoding>
+          , fusion::vector1<A0> >
+      , Modifiers>
+    {
+        typedef CharEncoding encoding;
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
+        typedef typename add_const<A0>::type const_string;
+        typedef typename mpl::if_<
+            no_case
+          , no_case_literal_string<const_string, false>
+          , literal_string<const_string, false> >::type
+        result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, unused_type) const
+        {
+            return op(fusion::at_c<0>(term.args), no_case());
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::false_) const
+        {
+            return result_type(str);
+        }
+        template <typename String>
+        result_type op(String const& str, mpl::true_) const
+        {
+            return result_type(traits::get_c_string(str), encoding());
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename String, bool no_attribute, typename Attribute
+      ,typename Context, typename Iterator>
+    struct handles_container<qi::literal_string<String, no_attribute>
+      , Attribute, Context, Iterator>
+      : mpl::true_ {};
+    template <typename String, bool no_attribute, typename Attribute
+      , typename Context, typename Iterator>
+    struct handles_container<qi::no_case_literal_string<String, no_attribute>
+      , Attribute, Context, Iterator>
+      : mpl::true_ {};
+}}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Char, typename T>
+    struct tst_node
+    {
+        tst_node(Char id)
+          : id(id), data(0), lt(0), eq(0), gt(0)
+        {
+        }
+        template <typename Alloc>
+        static void
+        destruct_node(tst_node* p, Alloc* alloc)
+        {
+            if (p)
+            {
+                if (p->data)
+                    alloc->delete_data(p->data);
+                destruct_node(p->lt, alloc);
+                destruct_node(p->eq, alloc);
+                destruct_node(p->gt, alloc);
+                alloc->delete_node(p);
+            }
+        }
+        template <typename Alloc>
+        static tst_node*
+        clone_node(tst_node* p, Alloc* alloc)
+        {
+            if (p)
+            {
+                tst_node* clone = alloc->new_node(p->id);
+                if (p->data)
+                    clone->data = alloc->new_data(*p->data);
+                clone->lt = clone_node(p->lt, alloc);
+                clone->eq = clone_node(p->eq, alloc);
+                clone->gt = clone_node(p->gt, alloc);
+                return clone;
+            }
+            return 0;
+        }
+        template <typename Iterator, typename Filter>
+        static T*
+        find(tst_node* start, Iterator& first, Iterator last, Filter filter)
+        {
+            if (first == last)
+                return 0;
+            Iterator i = first;
+            Iterator latest = first;
+            tst_node* p = start;
+            T* found = 0;
+            while (p && i != last)
+            {
+                typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                c = filter(*i);
+                if (c == p->id)
+                {
+                    if (p->data)
+                    {
+                        found = p->data;
+                        latest = i;
+                    }
+                    p = p->eq;
+                    i++;
+                }
+                else if (c < p->id)
+                {
+                    p = p->lt;
+                }
+                else
+                {
+                    p = p->gt;
+                }
+            }
+            if (found)
+                first = ++latest;
+            return found;
+        }
+        template <typename Iterator, typename Alloc>
+        static T*
+        add(
+            tst_node*& start
+          , Iterator first
+          , Iterator last
+          , typename boost::call_traits<T>::param_type val
+          , Alloc* alloc)
+        {
+            if (first == last)
+                return 0;
+            tst_node** pp = &start;
+            for(;;)
+            {
+                typename
+                    boost::detail::iterator_traits<Iterator>::value_type
+                c = *first;
+                if (*pp == 0)
+                    *pp = alloc->new_node(c);
+                tst_node* p = *pp;
+                if (c == p->id)
+                {
+                    if (++first == last)
+                    {
+                        if (p->data == 0)
+                            p->data = alloc->new_data(val);
+                        return p->data;
+                    }
+                    pp = &p->eq;
+                }
+                else if (c < p->id)
+                {
+                    pp = &p->lt;
+                }
+                else
+                {
+                    pp = &p->gt;
+                }
+            }
+        }
+        template <typename Iterator, typename Alloc>
+        static void
+        remove(tst_node*& p, Iterator first, Iterator last, Alloc* alloc)
+        {
+            if (p == 0 || first == last)
+                return;
+            typename
+                boost::detail::iterator_traits<Iterator>::value_type
+            c = *first;
+            if (c == p->id)
+            {
+                if (++first == last)
+                {
+                    if (p->data)
+                    {
+                        alloc->delete_data(p->data);
+                        p->data = 0;
+                    }
+                }
+                remove(p->eq, first, last, alloc);
+            }
+            else if (c < p->id)
+            {
+                remove(p->lt, first, last, alloc);
+            }
+            else
+            {
+                remove(p->gt, first, last, alloc);
+            }
+            if (p->data == 0 && p->lt == 0 && p->eq == 0 && p->gt == 0)
+            {
+                alloc->delete_node(p);
+                p = 0;
+            }
+        }
+        template <typename F>
+        static void
+        for_each(tst_node* p, std::basic_string<Char> prefix, F f)
+        {
+            if (p)
+            {
+                for_each(p->lt, prefix, f);
+                std::basic_string<Char> s = prefix + p->id;
+                for_each(p->eq, s, f);
+                if (p->data)
+                    f(s, *p->data);
+                for_each(p->gt, prefix, f);
+            }
+        }
+        Char id;
+        T* data;
+        tst_node* lt;
+        tst_node* eq;
+        tst_node* gt;
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    struct tst_pass_through
+    {
+        template <typename Char>
+        Char operator()(Char ch) const
+        {
+            return ch;
+        }
+    };
+    template <typename Char, typename T>
+    struct tst
+    {
+        typedef Char char_type;
+        typedef T value_type;
+        typedef detail::tst_node<Char, T> node;
+        tst()
+          : root(0)
+        {
+        }
+        ~tst()
+        {
+            clear();
+        }
+        tst(tst const& rhs)
+          : root(0)
+        {
+            copy(rhs);
+        }
+        tst& operator=(tst const& rhs)
+        {
+            return assign(rhs);
+        }
+        template <typename Iterator, typename Filter>
+        T* find(Iterator& first, Iterator last, Filter filter) const
+        {
+            return node::find(root, first, last, filter);
+        }
+        template <typename Iterator>
+        T* find(Iterator& first, Iterator last) const
+        {
+            return find(first, last, tst_pass_through());
+        }
+        template <typename Iterator>
+        T* add(
+            Iterator first
+          , Iterator last
+          , typename boost::call_traits<T>::param_type val)
+        {
+            return node::add(root, first, last, val, this);
+        }
+        template <typename Iterator>
+        void remove(Iterator first, Iterator last)
+        {
+            node::remove(root, first, last, this);
+        }
+        void clear()
+        {
+            node::destruct_node(root, this);
+            root = 0;
+        }
+        template <typename F>
+        void for_each(F f) const
+        {
+            node::for_each(root, std::basic_string<Char>(), f);
+        }
+    private:
+        friend struct detail::tst_node<Char, T>;
+        void copy(tst const& rhs)
+        {
+            root = node::clone_node(rhs.root, this);
+        }
+        tst& assign(tst const& rhs)
+        {
+            if (this != &rhs)
+            {
+                clear();
+                copy(rhs);
+            }
+            return *this;
+        }
+        node* root;
+        node* new_node(Char id)
+        {
+            return new node(id);
+        }
+        T* new_data(typename boost::call_traits<T>::param_type val)
+        {
+            return new T(val);
+        }
+        void delete_node(node* p)
+        {
+            delete p;
+        }
+        void delete_data(T* p)
+        {
+            delete p;
+        }
+    };
+}}}
+namespace boost
+{
+    namespace range_detail
+    {
+        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+        template<class T, class Enabler = void>
+        struct has_range_iterator_impl
+            : boost::mpl::false_
+        {
+        };
+        template<class T>
+        struct has_range_iterator_impl<T, typename enable_if< has_type< range_mutable_iterator<T> > >::type>
+            : boost::mpl::true_
+        {
+        };
+        template<class T, class Enabler = void>
+        struct has_range_const_iterator_impl
+            : boost::mpl::false_
+        {
+        };
+        template<class T>
+        struct has_range_const_iterator_impl<T, typename enable_if< has_type< range_const_iterator<T> > >::type>
+            : boost::mpl::true_
+        {
+        };
+    }
+    template<class T>
+    struct has_range_iterator
+        : range_detail::has_range_iterator_impl<T>
+    {};
+    template<class T>
+    struct has_range_const_iterator
+        : range_detail::has_range_const_iterator_impl<T>
+    {};
+}
+namespace boost
+{
+    template< typename C >
+    struct range_result_iterator : range_iterator<C>
+    { };
+}
+namespace boost
+{
+    template< typename C >
+    struct range_const_reverse_iterator : range_reverse_iterator<const C>
+    { };
+}
+namespace boost
+{
+    template< typename C >
+    struct range_reverse_result_iterator : range_reverse_iterator<C>
+    { };
+}
+namespace boost
+{
+    namespace detail
+    {
+        template< typename C >
+        struct range_size
+        {
+            typedef typename C::size_type type;
+        };
+        template< typename Iterator >
+        struct range_size< std::pair<Iterator,Iterator> >
+        {
+            typedef std::size_t type;
+        };
+        template< typename T, std::size_t sz >
+        struct range_size< T[sz] >
+        {
+            typedef std::size_t type;
+        };
+    }
+    template< class T >
+    struct range_size :
+        detail::range_size<T>
+    { };
+    template< class T >
+    struct range_size<const T >
+        : detail::range_size<T>
+    { };
+}
+namespace boost
+{
+    template< class T >
+    struct range_category : iterator_category< typename range_iterator<T>::type >
+    { };
+}
+namespace boost
+{
+    template< class T >
+    struct range_reference : iterator_reference< typename range_iterator<T>::type >
+    { };
+}
+namespace boost
+{
+    template< class T >
+    struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
+    { };
+}
+namespace boost
+{
+    template< class ForwardRange >
+    class sub_range : public iterator_range< typename range_iterator<ForwardRange>::type >
+    {
+        typedef typename range_iterator<ForwardRange>::type iterator_t;
+        typedef iterator_range< iterator_t > base;
+        typedef typename base::impl impl;
+    public:
+        typedef typename range_value<ForwardRange>::type value_type;
+        typedef typename range_iterator<ForwardRange>::type iterator;
+        typedef typename range_iterator<const ForwardRange>::type const_iterator;
+        typedef typename range_difference<ForwardRange>::type difference_type;
+        typedef typename range_size<ForwardRange>::type size_type;
+        typedef typename base::reference reference;
+    public:
+        typedef typename
+                boost::mpl::if_< boost::is_reference<reference>,
+                                 const typename boost::remove_reference<reference>::type&,
+                                 reference >::type const_reference;
+    public:
+        sub_range() : base()
+        { }
+        template< class ForwardRange2 >
+        sub_range( ForwardRange2& r ) :
+            base( r )
+        { }
+        template< class ForwardRange2 >
+        sub_range( const ForwardRange2& r ) :
+            base( r )
+        { }
+        template< class Iter >
+        sub_range( Iter first, Iter last ) :
+            base( first, last )
+        { }
+        template< class ForwardRange2 >
+        sub_range& operator=( ForwardRange2& r )
+        {
+            base::operator=( r );
+            return *this;
+        }
+        template< class ForwardRange2 >
+        sub_range& operator=( const ForwardRange2& r )
+        {
+            base::operator=( r );
+            return *this;
+        }
+        sub_range& operator=( const sub_range& r )
+        {
+            base::operator=( static_cast<const base&>(r) );
+            return *this;
+        }
+    public:
+        iterator begin() { return base::begin(); }
+        const_iterator begin() const { return base::begin(); }
+        iterator end() { return base::end(); }
+        const_iterator end() const { return base::end(); }
+        difference_type size() const { return base::size(); }
+    public:
+        reference front()
+        {
+            return base::front();
+        }
+        const_reference front() const
+        {
+            return base::front();
+        }
+        reference back()
+        {
+            return base::back();
+        }
+        const_reference back() const
+        {
+            return base::back();
+        }
+        reference operator[]( difference_type sz )
+        {
+            return base::operator[](sz);
+        }
+        const_reference operator[]( difference_type sz ) const
+        {
+            return base::operator[](sz);
+        }
+    };
+    template< class ForwardRange, class ForwardRange2 >
+    inline bool operator==( const sub_range<ForwardRange>& l,
+                            const sub_range<ForwardRange2>& r )
+    {
+        return boost::equal( l, r );
+    }
+    template< class ForwardRange, class ForwardRange2 >
+    inline bool operator!=( const sub_range<ForwardRange>& l,
+                            const sub_range<ForwardRange2>& r )
+    {
+        return !boost::equal( l, r );
+    }
+    template< class ForwardRange, class ForwardRange2 >
+    inline bool operator<( const sub_range<ForwardRange>& l,
+                           const sub_range<ForwardRange2>& r )
+    {
+        return iterator_range_detail::less_than( l, r );
+    }
+}
+namespace boost { namespace spirit { namespace qi
+{
+    template <
+        typename Char = char
+      , typename T = unused_type
+      , typename Lookup = tst<Char, T>
+      , typename Filter = tst_pass_through>
+    struct symbols
+      : proto::extends<
+            typename proto::terminal<
+                reference<symbols<Char, T, Lookup, Filter> >
+            >::type
+          , symbols<Char, T, Lookup, Filter>
+        >
+      , primitive_parser<symbols<Char, T, Lookup, Filter> >
+    {
+        typedef Char char_type;
+        typedef T value_type;
+        typedef symbols<Char, T, Lookup, Filter> this_type;
+        typedef reference<this_type> reference_;
+        typedef typename proto::terminal<reference_>::type terminal;
+        typedef proto::extends<terminal, this_type> base_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef value_type type;
+        };
+        symbols(std::string const& name = "symbols")
+          : base_type(terminal::make(reference_(*this)))
+          , add(*this)
+          , remove(*this)
+          , lookup(new Lookup())
+          , name_(name)
+        {
+        }
+        symbols(symbols const& syms)
+          : base_type(terminal::make(reference_(*this)))
+          , add(*this)
+          , remove(*this)
+          , lookup(syms.lookup)
+          , name_(syms.name_)
+        {
+        }
+        template <typename Filter_>
+        symbols(symbols<Char, T, Lookup, Filter_> const& syms)
+          : base_type(terminal::make(reference_(*this)))
+          , add(*this)
+          , remove(*this)
+          , lookup(syms.lookup)
+          , name_(syms.name_)
+        {
+        }
+        template <typename Symbols>
+        symbols(Symbols const& syms, std::string const& name = "symbols")
+          : base_type(terminal::make(reference_(*this)))
+          , add(*this)
+          , remove(*this)
+          , lookup(new Lookup())
+          , name_(name)
+        {
+            typename range_const_iterator<Symbols>::type si = boost::begin(syms);
+            while (si != boost::end(syms))
+                add(*si++);
+        }
+        template <typename Symbols, typename Data>
+        symbols(Symbols const& syms, Data const& data
+              , std::string const& name = "symbols")
+          : base_type(terminal::make(reference_(*this)))
+          , add(*this)
+          , remove(*this)
+          , lookup(new Lookup())
+          , name_(name)
+        {
+            typename range_const_iterator<Symbols>::type si = boost::begin(syms);
+            typename range_const_iterator<Data>::type di = boost::begin(data);
+            while (si != boost::end(syms))
+                add(*si++, *di++);
+        }
+        symbols&
+        operator=(symbols const& rhs)
+        {
+            name_ = rhs.name_;
+            *lookup = *rhs.lookup;
+            return *this;
+        }
+        template <typename Filter_>
+        symbols&
+        operator=(symbols<Char, T, Lookup, Filter_> const& rhs)
+        {
+            name_ = rhs.name_;
+            *lookup = *rhs.lookup;
+            return *this;
+        }
+        void clear()
+        {
+            lookup->clear();
+        }
+        struct adder;
+        struct remover;
+        template <typename Str>
+        adder const&
+        operator=(Str const& str)
+        {
+            lookup->clear();
+            return add(str);
+        }
+        template <typename Str>
+        friend adder const&
+        operator+=(symbols& sym, Str const& str)
+        {
+            return sym.add(str);
+        }
+        template <typename Str>
+        friend remover const&
+        operator-=(symbols& sym, Str const& str)
+        {
+            return sym.remove(str);
+        }
+        template <typename Str>
+        friend adder const&
+        operator+=(symbols& sym, Str& str)
+        {
+            return sym.add(str);
+        }
+        template <typename Str>
+        friend remover const&
+        operator-=(symbols& sym, Str& str)
+        {
+            return sym.remove(str);
+        }
+        template <typename F>
+        void for_each(F f) const
+        {
+            lookup->for_each(f);
+        }
+        template <typename Str>
+        value_type& at(Str const& str)
+        {
+            return *lookup->add(traits::get_begin<Char>(str)
+                , traits::get_end<Char>(str), T());
+        }
+        template <typename Iterator>
+        value_type* prefix_find(Iterator& first, Iterator const& last)
+        {
+            return lookup->find(first, last, Filter());
+        }
+        template <typename Iterator>
+        value_type const* prefix_find(Iterator& first, Iterator const& last) const
+        {
+            return lookup->find(first, last, Filter());
+        }
+        template <typename Str>
+        value_type* find(Str const& str)
+        {
+            return find_impl(traits::get_begin<Char>(str)
+                , traits::get_end<Char>(str));
+        }
+        template <typename Str>
+        value_type const* find(Str const& str) const
+        {
+            return find_impl(traits::get_begin<Char>(str)
+                , traits::get_end<Char>(str));
+        }
+private:
+        template <typename Iterator>
+        value_type* find_impl(Iterator begin, Iterator end)
+        {
+            value_type* r = lookup->find(begin, end, Filter());
+            return begin == end ? r : 0;
+        }
+        template <typename Iterator>
+        value_type const* find_impl(Iterator begin, Iterator end) const
+        {
+            value_type const* r = lookup->find(begin, end, Filter());
+            return begin == end ? r : 0;
+        }
+public:
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper, Attribute& attr) const
+        {
+            qi::skip_over(first, last, skipper);
+            if (value_type* val_ptr
+                = lookup->find(first, last, Filter()))
+            {
+                spirit::traits::assign_to(*val_ptr, attr);
+                return true;
+            }
+            return false;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info(name_);
+        }
+        void name(std::string const &str)
+        {
+            name_ = str;
+        }
+        std::string const &name() const
+        {
+            return name_;
+        }
+        struct adder
+        {
+            template <typename, typename = unused_type, typename = unused_type>
+            struct result { typedef adder const& type; };
+            adder(symbols& sym)
+              : sym(sym)
+            {
+            }
+            template <typename Iterator>
+            adder const&
+            operator()(Iterator const& first, Iterator const& last, T const& val) const
+            {
+                sym.lookup->add(first, last, val);
+                return *this;
+            }
+            template <typename Str>
+            adder const&
+            operator()(Str const& s, T const& val = T()) const
+            {
+                sym.lookup->add(traits::get_begin<Char>(s)
+                  , traits::get_end<Char>(s), val);
+                return *this;
+            }
+            template <typename Str>
+            adder const&
+            operator,(Str const& s) const
+            {
+                sym.lookup->add(traits::get_begin<Char>(s)
+                  , traits::get_end<Char>(s), T());
+                return *this;
+            }
+            symbols& sym;
+        private:
+            adder& operator= (adder const&);
+        };
+        struct remover
+        {
+            template <typename, typename = unused_type, typename = unused_type>
+            struct result { typedef remover const& type; };
+            remover(symbols& sym)
+              : sym(sym)
+            {
+            }
+            template <typename Iterator>
+            remover const&
+            operator()(Iterator const& first, Iterator const& last) const
+            {
+                sym.lookup->remove(first, last);
+                return *this;
+            }
+            template <typename Str>
+            remover const&
+            operator()(Str const& s) const
+            {
+                sym.lookup->remove(traits::get_begin<Char>(s)
+                  , traits::get_end<Char>(s));
+                return *this;
+            }
+            template <typename Str>
+            remover const&
+            operator,(Str const& s) const
+            {
+                sym.lookup->remove(traits::get_begin<Char>(s)
+                  , traits::get_end<Char>(s));
+                return *this;
+            }
+            symbols& sym;
+        private:
+            remover& operator= (remover const&);
+        };
+        adder add;
+        remover remove;
+        shared_ptr<Lookup> lookup;
+        std::string name_;
+    };
+    template <typename Char, typename T, typename Lookup
+      , typename Filter, typename Modifiers>
+    struct make_primitive<reference<symbols<Char, T, Lookup, Filter> >, Modifiers>
+    {
+        template <typename CharEncoding>
+        struct no_case_filter
+        {
+            Char operator()(Char ch) const
+            {
+                return static_cast<Char>(CharEncoding::tolower(ch));
+            }
+        };
+        typedef has_modifier<Modifiers, tag::char_code_base<tag::no_case> > no_case;
+        typedef reference<symbols<Char, T, Lookup, Filter> > reference_;
+        typedef no_case_filter<
+            typename spirit::detail::get_encoding_with_case<
+                Modifiers
+              , char_encoding::standard
+              , no_case::value>::type>
+        nc_filter;
+        typedef typename mpl::if_<
+            no_case
+          , symbols<Char, T, Lookup, nc_filter>
+          , reference_>::type
+        result_type;
+        result_type operator()(reference_ ref, unused_type) const
+        {
+            return result_type(ref.ref.get());
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Char, typename T, typename Lookup, typename Filter
+      , typename Attr, typename Context, typename Iterator>
+    struct handles_container<qi::symbols<Char, T, Lookup, Filter>, Attr, Context, Iterator>
+      : traits::is_container<Attr> {};
+}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Expr>
+    inline info what(Expr const& expr)
+    {
+        struct error_invalid_expression; typedef struct error_invalid_expression27 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg27; enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg27::assert_arg() ) ) };
+        return compile<qi::domain>(expr).what(unused);
+    }
+}}}
+namespace boost { namespace spirit {
+    namespace iterator_policies
+    {
+        struct input_iterator;
+        struct buffering_input_iterator;
+        struct istream;
+        struct lex_input;
+        struct functor_input;
+        struct split_functor_input;
+        struct ref_counted;
+        struct first_owner;
+        class illegal_backtracking;
+        struct buf_id_check;
+        struct no_check;
+        struct split_std_deque;
+        template<std::size_t N> struct fixed_size_queue;
+        template<typename Ownership = ref_counted
+          , typename Checking = no_check
+          , typename Input = buffering_input_iterator
+          , typename Storage = split_std_deque>
+        struct default_policy;
+    }
+    template <typename T
+      , typename Policies = iterator_policies::default_policy<> >
+    class multi_pass;
+    template <typename T, typename Policies>
+    void swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y);
+}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename T, typename Policies>
+    void clear_queue(multi_pass<T, Policies>&
+      , clear_mode::enum_type mode = clear_mode::clear_if_enabled);
+    template <typename T, typename Policies>
+    void inhibit_clear_queue(multi_pass<T, Policies>&, bool);
+    template <typename T, typename Policies>
+    bool inhibit_clear_queue(multi_pass<T, Policies>&);
+    template <typename T, typename Policies>
+    struct is_multi_pass<multi_pass<T, Policies> > : mpl::true_ {};
+}}}
+namespace boost { namespace spirit { namespace detail
+{
+    struct default_input_policy
+    {
+        default_input_policy() {}
+        template <typename Functor>
+        default_input_policy(Functor const&) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+        void swap(default_input_policy&) {}
+        template <typename MultiPass, typename TokenType>
+        static void advance_input(MultiPass& mp);
+        template <typename MultiPass>
+        static typename MultiPass::reference get_input(MultiPass& mp);
+        template <typename MultiPass>
+        static bool input_at_eof(MultiPass const& mp);
+        template <typename MultiPass, typename TokenType>
+        static bool input_is_valid(MultiPass& mp, TokenType& curtok);
+    };
+    struct default_ownership_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+        void swap(default_ownership_policy&) {}
+        template <typename MultiPass>
+        static void clone(MultiPass&) {}
+        template <typename MultiPass>
+        static bool release(MultiPass& mp);
+        template <typename MultiPass>
+        static bool is_unique(MultiPass const& mp);
+    };
+    struct default_storage_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+        void swap(default_storage_policy&) {}
+        template <typename MultiPass>
+        static typename MultiPass::reference dereference(MultiPass const& mp);
+        template <typename MultiPass>
+        static void increment(MultiPass&) {}
+        template <typename MultiPass>
+        static void clear_queue(MultiPass&) {}
+        template <typename MultiPass>
+        static bool is_eof(MultiPass const& mp);
+        template <typename MultiPass>
+        static bool equal_to(MultiPass const& mp, MultiPass const& x);
+        template <typename MultiPass>
+        static bool less_than(MultiPass const& mp, MultiPass const& x);
+    };
+    struct default_checking_policy
+    {
+        template <typename MultiPass>
+        static void destroy(MultiPass&) {}
+        void swap(default_checking_policy&) {}
+        template <typename MultiPass>
+        static void docheck(MultiPass const&) {}
+        template <typename MultiPass>
+        static void clear_queue(MultiPass&) {}
+    };
+}}}
+namespace boost
+{
+namespace detail
+{
+class atomic_count
+{
+public:
+    explicit atomic_count( long v ) : value_( v ) {}
+    long operator++()
+    {
+        return __sync_add_and_fetch( &value_, 1 );
+    }
+    long operator--()
+    {
+        return __sync_add_and_fetch( &value_, -1 );
+    }
+    operator long() const
+    {
+        return __sync_fetch_and_add( &value_, 0 );
+    }
+private:
+    atomic_count(atomic_count const &);
+    atomic_count & operator=(atomic_count const &);
+    mutable long value_;
+};
+}
+}
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    struct ref_counted
+    {
+        struct unique
+        {
+            void swap(unique&) {}
+            template <typename MultiPass>
+            static void clone(MultiPass& mp)
+            {
+                if (0 != mp.shared())
+                    ++mp.shared()->count;
+            }
+            template <typename MultiPass>
+            static bool release(MultiPass& mp)
+            {
+                return 0 != mp.shared() && 0 == --mp.shared()->count;
+            }
+            template <typename MultiPass>
+            static bool is_unique(MultiPass const& mp)
+            {
+                return 0 == mp.shared() || 1 == mp.shared()->count;
+            }
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+        };
+        struct shared
+        {
+            shared() : count(1) {}
+            boost::detail::atomic_count count;
+        };
+    };
+}}}
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    struct no_check
+    {
+        struct unique : public detail::default_checking_policy {};
+        struct shared {};
+    };
+}}}
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    struct istream
+    {
+        template <typename T>
+        class unique
+        {
+        private:
+            typedef typename T::char_type result_type;
+        public:
+            typedef typename T::off_type difference_type;
+            typedef typename T::off_type distance_type;
+            typedef result_type const* pointer;
+            typedef result_type const& reference;
+            typedef result_type value_type;
+        protected:
+            unique() {}
+            explicit unique(T&) {}
+            void swap(unique&) {}
+        public:
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+            template <typename MultiPass>
+            static typename MultiPass::reference get_input(MultiPass& mp)
+            {
+                if (!mp.shared()->initialized_)
+                    mp.shared()->read_one();
+                return mp.shared()->curtok_;
+            }
+            template <typename MultiPass>
+            static void advance_input(MultiPass& mp)
+            {
+                mp.shared()->peek_one();
+            }
+            template <typename MultiPass>
+            static bool input_at_eof(MultiPass const& mp)
+            {
+                return mp.shared()->eof_reached_;
+            }
+            template <typename MultiPass>
+            static bool input_is_valid(MultiPass const& mp, value_type const&)
+            {
+                return mp.shared()->initialized_;
+            }
+        };
+        template <typename T>
+        struct shared
+        {
+        private:
+            typedef typename T::char_type result_type;
+        public:
+            explicit shared(T& input)
+              : input_(input), curtok_(-1)
+              , initialized_(false), eof_reached_(false)
+            {
+                peek_one();
+            }
+            void read_one()
+            {
+                if (!(input_ >> curtok_)) {
+                    initialized_ = false;
+                    eof_reached_ = true;
+                }
+                else {
+                    initialized_ = true;
+                }
+            }
+            void peek_one()
+            {
+                input_.peek();
+                initialized_ = false;
+                eof_reached_ = input_.eof();
+            }
+            T& input_;
+            result_type curtok_;
+            bool initialized_;
+            bool eof_reached_;
+        };
+    };
+}}}
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    struct split_std_deque
+    {
+        enum { threshold = 16 };
+        template <typename Value>
+        class unique
+        {
+        private:
+            typedef std::vector<Value> queue_type;
+        protected:
+            unique() : queued_position(0) {}
+            unique(unique const& x)
+              : queued_position(x.queued_position) {}
+            void swap(unique& x)
+            {
+                boost::swap(queued_position, x.queued_position);
+            }
+            template <typename MultiPass>
+            static typename MultiPass::reference
+            dereference(MultiPass const& mp)
+            {
+                queue_type& queue = mp.shared()->queued_elements;
+                typename queue_type::size_type size = queue.size();
+                (static_cast<void> (0));
+                if (mp.queued_position == size)
+                {
+                    if (size >= threshold && MultiPass::is_unique(mp))
+                    {
+                        queue.clear();
+                        mp.queued_position = 0;
+                    }
+                    return MultiPass::get_input(mp);
+                }
+                return queue[mp.queued_position];
+            }
+            template <typename MultiPass>
+            static void increment(MultiPass& mp)
+            {
+                queue_type& queue = mp.shared()->queued_elements;
+                typename queue_type::size_type size = queue.size();
+                (static_cast<void> (0));
+                if (mp.queued_position == size)
+                {
+                    if (size >= threshold && MultiPass::is_unique(mp))
+                    {
+                        queue.clear();
+                        mp.queued_position = 0;
+                    }
+                    else
+                    {
+                        queue.push_back(MultiPass::get_input(mp));
+                        ++mp.queued_position;
+                    }
+                    MultiPass::advance_input(mp);
+                }
+                else
+                {
+                    ++mp.queued_position;
+                }
+            }
+            template <typename MultiPass>
+            static void clear_queue(MultiPass& mp)
+            {
+                mp.shared()->queued_elements.clear();
+                mp.queued_position = 0;
+            }
+            template <typename MultiPass>
+            static bool is_eof(MultiPass const& mp)
+            {
+                return mp.queued_position == mp.shared()->queued_elements.size()
+                    && MultiPass::input_at_eof(mp);
+            }
+            template <typename MultiPass>
+            static bool equal_to(MultiPass const& mp, MultiPass const& x)
+            {
+                return mp.queued_position == x.queued_position;
+            }
+            template <typename MultiPass>
+            static bool less_than(MultiPass const& mp, MultiPass const& x)
+            {
+                return mp.queued_position < x.queued_position;
+            }
+            template <typename MultiPass>
+            static void destroy(MultiPass&) {}
+        protected:
+            mutable typename queue_type::size_type queued_position;
+        };
+        template <typename Value>
+        struct shared
+        {
+            shared()
+            {
+                queued_elements.reserve(threshold);
+            }
+            typedef std::vector<Value> queue_type;
+            queue_type queued_elements;
+        };
+    };
+}}}
+namespace boost { namespace spirit { namespace iterator_policies
+{
+    template <typename T
+      , typename Ownership, typename Checking, typename Input, typename Storage
+      , bool OwnershipIsEmpty = boost::is_empty<Ownership>::value
+      , bool CheckingIsEmpty = boost::is_empty<Checking>::value
+      , bool InputIsEmpty = boost::is_empty<Input>::value>
+    struct multi_pass_unique;
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, false, false>
+      : Ownership, Checking, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Checking::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, false, true>
+      : Ownership, Checking, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Checking::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, true, false>
+      : Ownership, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , false, true, true>
+      : Ownership, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Ownership::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Ownership::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, false, false>
+      : Checking, Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Checking::swap(x);
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, false, true>
+      : Checking, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Checking::destroy(mp);
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Checking::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, true, false>
+      : Input, Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T& x) : Input(x) {}
+        multi_pass_unique(T const& x) : Input(x) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Input::swap(x);
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+    template <typename T, typename Ownership, typename Checking
+      , typename Input, typename Storage>
+    struct multi_pass_unique<T, Ownership, Checking, Input, Storage
+          , true, true, true>
+      : Storage
+    {
+        multi_pass_unique() {}
+        multi_pass_unique(T const&) {}
+        template <typename MultiPass>
+        static void destroy(MultiPass& mp)
+        {
+            Input::destroy(mp);
+            Storage::destroy(mp);
+        }
+        void swap(multi_pass_unique& x)
+        {
+            this->Storage::swap(x);
+        }
+        template <typename MultiPass>
+        inline static void clear_queue(MultiPass& mp)
+        {
+            Checking::clear_queue(mp);
+            Storage::clear_queue(mp);
+        }
+        template <typename MultiPass>
+        inline static void advance_input(MultiPass& mp)
+            { Input::advance_input(mp); }
+        template <typename MultiPass>
+        inline static typename MultiPass::reference get_input(MultiPass& mp)
+            { return Input::get_input(mp); }
+        template <typename MultiPass>
+        inline static bool input_at_eof(MultiPass const& mp)
+            { return Input::input_at_eof(mp); }
+        template <typename MultiPass, typename TokenType>
+        inline static bool input_is_valid(MultiPass& mp, TokenType& curtok)
+            { return Input::input_is_valid(mp, curtok); }
+        template <typename MultiPass>
+        inline static void docheck(MultiPass const& mp)
+            { Checking::docheck(mp); }
+        template <typename MultiPass>
+        inline static void clone(MultiPass& mp)
+            { Ownership::clone(mp); }
+        template <typename MultiPass>
+        inline static bool release(MultiPass& mp)
+            { return Ownership::release(mp); }
+        template <typename MultiPass>
+        inline static bool is_unique(MultiPass const& mp)
+            { return Ownership::is_unique(mp); }
+    };
+    template<typename T, typename Ownership, typename Checking, typename Input
+      , typename Storage>
+    struct multi_pass_shared : Ownership, Checking, Input, Storage
+    {
+        explicit multi_pass_shared(T& input) : Input(input) {}
+        explicit multi_pass_shared(T const& input) : Input(input) {}
+    };
+    template<typename Ownership, typename Checking, typename Input
+      , typename Storage>
+    struct default_policy
+    {
+        typedef Ownership ownership_policy;
+        typedef Checking checking_policy;
+        typedef Input input_policy;
+        typedef Storage storage_policy;
+        template <typename T>
+        struct unique : multi_pass_unique<T
+          , typename Ownership::unique, typename Checking::unique
+          , typename Input::template unique<T>
+          , typename Storage::template unique<
+                typename Input::template unique<T>::value_type> >
+        {
+            typedef typename Ownership::unique ownership_policy;
+            typedef typename Checking::unique checking_policy;
+            typedef typename Input::template unique<T>
+                input_policy;
+            typedef typename Storage::template unique<
+                typename input_policy::value_type> storage_policy;
+            typedef multi_pass_unique<T, ownership_policy, checking_policy
+              , input_policy, storage_policy> unique_base_type;
+            unique() {}
+            explicit unique(T& input) : unique_base_type(input) {}
+            explicit unique(T const& input) : unique_base_type(input) {}
+        };
+        template <typename T>
+        struct shared : multi_pass_shared<T
+          , typename Ownership::shared, typename Checking::shared
+          , typename Input::template shared<T>
+          , typename Storage::template shared<
+                typename Input::template unique<T>::value_type> >
+        {
+            typedef typename Ownership::shared ownership_policy;
+            typedef typename Checking::shared checking_policy;
+            typedef typename Input::template shared<T>
+                input_policy;
+            typedef typename Storage::template shared<
+                typename Input::template unique<T>::value_type>
+            storage_policy;
+            typedef multi_pass_shared<T, ownership_policy, checking_policy
+              , input_policy, storage_policy> shared_base_type;
+            explicit shared(T& input)
+              : shared_base_type(input), inhibit_clear_queue_(false) {}
+            explicit shared(T const& input)
+              : shared_base_type(input), inhibit_clear_queue_(false) {}
+            bool inhibit_clear_queue_;
+        };
+    };
+}}}
+namespace boost { namespace spirit
+{
+    template<typename T, typename Policies>
+    class multi_pass
+      : private boost::base_from_member<
+            typename Policies::template shared<T>*>
+      , public Policies::template unique<T>
+    {
+    private:
+        typedef typename Policies::template unique<T>
+            policies_base_type;
+        typedef typename Policies::template shared<T>
+            shared_data_type;
+        typedef boost::base_from_member<shared_data_type*> member_base;
+        typedef typename policies_base_type::input_policy iterator_type;
+    public:
+        typedef std::forward_iterator_tag iterator_category;
+        typedef typename iterator_type::value_type value_type;
+        typedef typename iterator_type::difference_type difference_type;
+        typedef typename iterator_type::distance_type distance_type;
+        typedef typename iterator_type::reference reference;
+        typedef typename iterator_type::pointer pointer;
+        multi_pass() : member_base(static_cast<shared_data_type*>(0)) {}
+        explicit multi_pass(T& input)
+          : member_base(new shared_data_type(input)), policies_base_type(input) {}
+        explicit multi_pass(T const& input)
+          : member_base(new shared_data_type(input)), policies_base_type(input) {}
+        multi_pass(multi_pass const& x)
+          : member_base(x.member), policies_base_type(x)
+        {
+            policies_base_type::clone(*this);
+        }
+        ~multi_pass()
+        {
+            if (policies_base_type::release(*this)) {
+                policies_base_type::destroy(*this);
+                delete this->member;
+            }
+        }
+        multi_pass& operator=(multi_pass const& x)
+        {
+            if (this != &x) {
+                multi_pass temp(x);
+                temp.swap(*this);
+            }
+            return *this;
+        }
+        void swap(multi_pass& x)
+        {
+            boost::swap(this->member, x.member);
+            this->policies_base_type::swap(x);
+        }
+        reference operator*() const
+        {
+            policies_base_type::docheck(*this);
+            return policies_base_type::dereference(*this);
+        }
+        pointer operator->() const
+        {
+            return &(operator*());
+        }
+        multi_pass& operator++()
+        {
+            policies_base_type::docheck(*this);
+            policies_base_type::increment(*this);
+            return *this;
+        }
+        multi_pass operator++(int)
+        {
+            multi_pass tmp(*this);
+            ++*this;
+            return tmp;
+        }
+        void clear_queue(traits::clear_mode::enum_type mode =
+            traits::clear_mode::clear_if_enabled)
+        {
+            if (mode == traits::clear_mode::clear_always || !inhibit_clear_queue())
+                policies_base_type::clear_queue(*this);
+        }
+        bool inhibit_clear_queue() const
+        {
+            return this->member->inhibit_clear_queue_;
+        }
+        void inhibit_clear_queue(bool flag)
+        {
+            this->member->inhibit_clear_queue_ = flag;
+        }
+        bool operator==(multi_pass const& y) const
+        {
+            if (is_eof())
+                return y.is_eof();
+            if (y.is_eof())
+                return false;
+            return policies_base_type::equal_to(*this, y);
+        }
+        bool operator<(multi_pass const& y) const
+        {
+            return policies_base_type::less_than(*this, y);
+        }
+        bool operator!=(multi_pass const& y)
+        {
+            return !(*this == y);
+        }
+        bool operator>(multi_pass const& y)
+        {
+            return y < *this;
+        }
+        bool operator>=(multi_pass const& y)
+        {
+            return !(*this < y);
+        }
+        bool operator<=(multi_pass const& y)
+        {
+            return !(y < *this);
+        }
+        shared_data_type* shared() const { return this->member; }
+    private:
+        bool is_eof() const
+        {
+            return (0 == this->member) || policies_base_type::is_eof(*this);
+        }
+    };
+    template <typename Policies, typename T>
+    inline multi_pass<T, Policies>
+    make_multi_pass(T& i)
+    {
+        return multi_pass<T, Policies>(i);
+    }
+    template <typename Policies, typename T>
+    inline multi_pass<T, Policies>
+    make_multi_pass(T const& i)
+    {
+        return multi_pass<T, Policies>(i);
+    }
+    template <typename T>
+    inline multi_pass<T>
+    make_default_multi_pass(T& i)
+    {
+        return multi_pass<T>(i);
+    }
+    template <typename T>
+    inline multi_pass<T>
+    make_default_multi_pass(T const& i)
+    {
+        return multi_pass<T>(i);
+    }
+    template <typename T, typename Policies>
+    inline void
+    swap(multi_pass<T, Policies> &x, multi_pass<T, Policies> &y)
+    {
+        x.swap(y);
+    }
+    namespace traits
+    {
+        template <typename T, typename Policies>
+        void clear_queue(multi_pass<T, Policies>& mp
+          , traits::clear_mode::enum_type mode)
+        {
+            mp.clear_queue(mode);
+        }
+        template <typename T, typename Policies>
+        void inhibit_clear_queue(multi_pass<T, Policies>& mp, bool flag)
+        {
+            mp.inhibit_clear_queue(flag);
+        }
+        template <typename T, typename Policies>
+        bool inhibit_clear_queue(multi_pass<T, Policies>& mp)
+        {
+            return mp.inhibit_clear_queue();
+        }
+    }
+}}
+namespace boost { namespace spirit
+{
+    template <typename Elem, typename Traits = std::char_traits<Elem> >
+    class basic_istream_iterator :
+        public multi_pass<
+            std::basic_istream<Elem, Traits>
+          , iterator_policies::default_policy<
+                iterator_policies::ref_counted
+              , iterator_policies::no_check
+              , iterator_policies::istream
+              , iterator_policies::split_std_deque>
+        >
+    {
+    private:
+        typedef multi_pass<
+            std::basic_istream<Elem, Traits>
+          , iterator_policies::default_policy<
+                iterator_policies::ref_counted
+              , iterator_policies::no_check
+              , iterator_policies::istream
+              , iterator_policies::split_std_deque>
+        > base_type;
+    public:
+        basic_istream_iterator()
+          : base_type() {}
+        explicit basic_istream_iterator(std::basic_istream<Elem, Traits>& x)
+          : base_type(x) {}
+        basic_istream_iterator(basic_istream_iterator const& x)
+          : base_type(x) {}
+        basic_istream_iterator operator= (base_type const& rhs)
+        {
+            this->base_type::operator=(rhs);
+            return *this;
+        }
+    };
+    typedef basic_istream_iterator<char> istream_iterator;
+}}
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Expr
+      , typename CopyExpr = mpl::false_, typename CopyAttr = mpl::false_
+      , typename Skipper = unused_type, typename Attribute = unused_type const>
+    struct match_manip
+    {
+        struct error_invalid_should_not_happen; typedef struct
+ error_invalid_should_not_happen35
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_should_not_happen::************ assert_arg()) () { return 0; } }
+ mpl_assert_arg35
+        ; enum { mpl_assertion_in_line_35 = sizeof( boost::mpl::assertion_failed<(!CopyExpr::value || !CopyAttr::value)>( mpl_assert_arg35::assert_arg() ) ) }
+                                                  ;
+        match_manip(Expr const& xpr, Skipper const& s, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(skip_flag::postskip) {}
+        match_manip(Expr const& xpr, Skipper const& s
+            , skip_flag::enum_type ps, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(ps) {}
+        Expr const& expr;
+        Skipper const& skipper;
+        Attribute& attr;
+        skip_flag::enum_type const post_skip;
+    private:
+        match_manip& operator= (match_manip const&);
+    };
+    template <typename Expr, typename Skipper, typename Attribute>
+    struct match_manip<Expr, mpl::false_, mpl::true_, Skipper, Attribute>
+    {
+        match_manip(Expr const& xpr, Skipper const& s, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(skip_flag::postskip) {}
+        match_manip(Expr const& xpr, Skipper const& s
+            , skip_flag::enum_type ps, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(ps) {}
+        Expr const& expr;
+        Skipper const& skipper;
+        Attribute attr;
+        skip_flag::enum_type const post_skip;
+    private:
+        match_manip& operator= (match_manip const&);
+    };
+    template <typename Expr, typename Skipper, typename Attribute>
+    struct match_manip<Expr, mpl::true_, mpl::false_, Skipper, Attribute>
+    {
+        match_manip(Expr const& xpr, Skipper const& s, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(skip_flag::postskip) {}
+        match_manip(Expr const& xpr, Skipper const& s
+            , skip_flag::enum_type ps, Attribute& a)
+          : expr(xpr), skipper(s), attr(a), post_skip(ps) {}
+        Expr expr;
+        Skipper const& skipper;
+        Attribute& attr;
+        skip_flag::enum_type const post_skip;
+    private:
+        match_manip& operator= (match_manip const&);
+    };
+    template <typename Expr, typename Enable = void>
+    struct match
+    {
+        struct error_invalid_expression; typedef struct error_invalid_expression103 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg103; enum { mpl_assertion_in_line_103 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg103::assert_arg() ) ) };
+    };
+    template <typename Expr>
+    struct match<Expr
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        typedef match_manip<Expr> type;
+        static type call(Expr const& expr)
+        {
+            return type(expr, unused, unused);
+        }
+    };
+    template <typename Expr, typename Skipper, typename Enable = void>
+    struct phrase_match
+    {
+        struct error_invalid_expression; typedef struct error_invalid_expression127 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Expr) { return 0; } } mpl_assert_arg127; enum { mpl_assertion_in_line_127 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Expr>::value ))>( mpl_assert_arg127::assert_arg() ) ) };
+    };
+    template <typename Expr, typename Skipper>
+    struct phrase_match<Expr, Skipper
+      , typename enable_if<traits::matches<qi::domain, Expr> >::type>
+    {
+        typedef match_manip<Expr, mpl::false_, mpl::false_, Skipper> type;
+        static type call(
+            Expr const& expr
+          , Skipper const& skipper
+          , skip_flag::enum_type post_skip)
+        {
+            struct error_invalid_expression; typedef struct error_invalid_expression144 : boost::mpl::assert_ { static boost::mpl::failed ************ (error_invalid_expression::************ assert_arg()) (Skipper) { return 0; } } mpl_assert_arg144; enum { mpl_assertion_in_line_144 = sizeof( boost::mpl::assertion_failed<(( boost::spirit::traits::matches<qi::domain, Skipper>::value ))>( mpl_assert_arg144::assert_arg() ) ) };
+            return type(expr, skipper, post_skip, unused);
+        }
+    };
+    template<typename Char, typename Traits, typename Expr
+      , typename CopyExpr, typename CopyAttr>
+    inline std::basic_istream<Char, Traits> &
+    operator>>(std::basic_istream<Char, Traits> &is,
+        match_manip<Expr, CopyExpr, CopyAttr> const& fm)
+    {
+        typedef spirit::basic_istream_iterator<Char, Traits> input_iterator;
+        input_iterator f(is);
+        input_iterator l;
+        if (!qi::parse(f, l, fm.expr))
+        {
+            is.setstate(std::ios_base::failbit);
+        }
+        return is;
+    }
+    template<typename Char, typename Traits, typename Expr
+      , typename CopyExpr, typename CopyAttr
+      , typename Attribute>
+    inline std::basic_istream<Char, Traits> &
+    operator>>(std::basic_istream<Char, Traits> &is,
+        match_manip<Expr, CopyExpr, CopyAttr, unused_type, Attribute> const& fm)
+    {
+        typedef spirit::basic_istream_iterator<Char, Traits> input_iterator;
+        input_iterator f(is);
+        input_iterator l;
+        if (!qi::parse(f, l, fm.expr, fm.attr))
+        {
+            is.setstate(std::ios_base::failbit);
+        }
+        return is;
+    }
+    template<typename Char, typename Traits, typename Expr
+      , typename CopyExpr, typename CopyAttr
+      , typename Skipper>
+    inline std::basic_istream<Char, Traits> &
+    operator>>(std::basic_istream<Char, Traits> &is,
+        match_manip<Expr, CopyExpr, CopyAttr, Skipper> const& fm)
+    {
+        typedef spirit::basic_istream_iterator<Char, Traits> input_iterator;
+        input_iterator f(is);
+        input_iterator l;
+        if (!qi::phrase_parse(
+                f, l, fm.expr, fm.skipper, fm.post_skip))
+        {
+            is.setstate(std::ios_base::failbit);
+        }
+        return is;
+    }
+    template<typename Char, typename Traits, typename Expr
+      , typename CopyExpr, typename CopyAttr
+      , typename Attribute, typename Skipper
+    >
+    inline std::basic_istream<Char, Traits> &
+    operator>>(
+        std::basic_istream<Char, Traits> &is,
+        match_manip<Expr, CopyExpr, CopyAttr, Attribute, Skipper> const& fm)
+    {
+        typedef spirit::basic_istream_iterator<Char, Traits> input_iterator;
+        input_iterator f(is);
+        input_iterator l;
+        if (!qi::phrase_parse(
+                f, l, fm.expr, fm.skipper, fm.post_skip, fm.attr))
+        {
+            is.setstate(std::ios_base::failbit);
+        }
+        return is;
+    }
+}}}}
+namespace boost { namespace iostreams { namespace detail {
+} } }
+namespace boost { namespace iostreams {
+const std::streamsize default_device_buffer_size =
+    4096;
+const std::streamsize default_filter_buffer_size =
+    128;
+const std::streamsize default_pback_buffer_size =
+    4;
+} }
+namespace boost { namespace iostreams {
+typedef mpl::true_ else_;
+template< typename Case1 = mpl::true_,
+          typename Type1 = mpl::void_,
+          typename Case2 = mpl::true_,
+          typename Type2 = mpl::void_,
+          typename Case3 = mpl::true_,
+          typename Type3 = mpl::void_,
+          typename Case4 = mpl::true_,
+          typename Type4 = mpl::void_,
+          typename Case5 = mpl::true_,
+          typename Type5 = mpl::void_,
+          typename Case6 = mpl::true_,
+          typename Type6 = mpl::void_,
+          typename Case7 = mpl::true_,
+          typename Type7 = mpl::void_,
+          typename Case8 = mpl::true_,
+          typename Type8 = mpl::void_,
+          typename Case9 = mpl::true_,
+          typename Type9 = mpl::void_,
+          typename Case10 = mpl::true_,
+          typename Type10 = mpl::void_,
+          typename Case11 = mpl::true_,
+          typename Type11 = mpl::void_,
+          typename Case12 = mpl::true_,
+          typename Type12 = mpl::void_ >
+struct select {
+    typedef typename
+            mpl::eval_if<
+                Case1, mpl::identity<Type1>, mpl::eval_if<
+                Case2, mpl::identity<Type2>, mpl::eval_if<
+                Case3, mpl::identity<Type3>, mpl::eval_if<
+                Case4, mpl::identity<Type4>, mpl::eval_if<
+                Case5, mpl::identity<Type5>, mpl::eval_if<
+                Case6, mpl::identity<Type6>, mpl::eval_if<
+                Case7, mpl::identity<Type7>, mpl::eval_if<
+                Case8, mpl::identity<Type8>, mpl::eval_if<
+                Case9, mpl::identity<Type9>, mpl::eval_if<
+                Case10, mpl::identity<Type10>, mpl::eval_if<
+                Case11, mpl::identity<Type11>, mpl::if_<
+                Case12, Type12, mpl::void_ > > > > > > > > > > >
+            >::type type;
+};
+} }
+namespace boost { namespace iostreams { namespace detail {
+inline std::ios::failure cant_read()
+{ return std::ios::failure("no read access"); }
+inline std::ios::failure cant_write()
+{ return std::ios::failure("no write access"); }
+inline std::ios::failure cant_seek()
+{ return std::ios::failure("no random access"); }
+inline std::ios::failure bad_read()
+{ return std::ios::failure("bad read"); }
+inline std::ios::failure bad_putback()
+{ return std::ios::failure("putback buffer full"); }
+inline std::ios::failure bad_write()
+{ return std::ios::failure("bad write"); }
+inline std::ios::failure write_area_exhausted()
+{ return std::ios::failure("write area exhausted"); }
+inline std::ios::failure bad_seek()
+{ return std::ios::failure("bad seek"); }
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Result>
+struct execute_traits_impl {
+    typedef Result result_type;
+    template<typename Op>
+    static Result execute(Op op) { return op(); }
+};
+template<>
+struct execute_traits_impl<void> {
+    typedef int result_type;
+    template<typename Op>
+    static int execute(Op op) { op(); return 0; }
+};
+template< typename Op,
+          typename Result =
+                  typename boost::result_of<Op()>::type
+          >
+struct execute_traits
+    : execute_traits_impl<Result>
+    { };
+template<typename Op>
+typename execute_traits<Op>::result_type
+execute_all(Op op)
+{
+    return execute_traits<Op>::execute(op);
+}
+        template<typename Op, typename C0> typename execute_traits<Op>::result_type execute_all(Op op, C0 c0) { typename execute_traits<Op>::result_type r; try { r = boost::iostreams::detail::execute_all( op ); } catch (...) { try { c0(); } catch (...) { } throw; } c0(); return r; }
+        template<typename Op, typename C0 , typename C1> typename execute_traits<Op>::result_type execute_all(Op op, C0 c0 , C1 c1) { typename execute_traits<Op>::result_type r; try { r = boost::iostreams::detail::execute_all( op , c0 ); } catch (...) { try { c1(); } catch (...) { } throw; } c1(); return r; }
+        template<typename Op, typename C0 , typename C1 , typename C2> typename execute_traits<Op>::result_type execute_all(Op op, C0 c0 , C1 c1 , C2 c2) { typename execute_traits<Op>::result_type r; try { r = boost::iostreams::detail::execute_all( op , c0 , c1 ); } catch (...) { try { c2(); } catch (...) { } throw; } c2(); return r; }
+        template<typename Op, typename C0 , typename C1 , typename C2 , typename C3> typename execute_traits<Op>::result_type execute_all(Op op, C0 c0 , C1 c1 , C2 c2 , C3 c3) { typename execute_traits<Op>::result_type r; try { r = boost::iostreams::detail::execute_all( op , c0 , c1 , c2 ); } catch (...) { try { c3(); } catch (...) { } throw; } c3(); return r; }
+        template<typename Op, typename C0 , typename C1 , typename C2 , typename C3 , typename C4> typename execute_traits<Op>::result_type execute_all(Op op, C0 c0 , C1 c1 , C2 c2 , C3 c3 , C4 c4) { typename execute_traits<Op>::result_type r; try { r = boost::iostreams::detail::execute_all( op , c0 , c1 , c2 , c3 ); } catch (...) { try { c4(); } catch (...) { } throw; } c4(); return r; }
+template<class InIt, class Op>
+Op execute_foreach(InIt first, InIt last, Op op)
+{
+    if (first == last)
+        return op;
+    try {
+        op(*first);
+    } catch (...) {
+        try {
+            ++first;
+            boost::iostreams::detail::execute_foreach(first, last, op);
+        } catch (...) { }
+        throw;
+    }
+    ++first;
+    return boost::iostreams::detail::execute_foreach(first, last, op);
+}
+} } }
+namespace boost { namespace iostreams {
+struct any_tag { };
+namespace detail { struct two_sequence : virtual any_tag { }; }
+namespace detail { struct random_access : virtual any_tag { }; }
+namespace detail { struct one_head : virtual any_tag { }; }
+namespace detail { struct two_head : virtual any_tag { }; }
+struct input : virtual any_tag { };
+struct output : virtual any_tag { };
+struct bidirectional : virtual input, virtual output, detail::two_sequence { };
+struct dual_use : virtual input, virtual output { };
+struct input_seekable : virtual input, virtual detail::random_access { };
+struct output_seekable : virtual output, virtual detail::random_access { };
+struct seekable
+    : virtual input_seekable,
+      virtual output_seekable,
+      detail::one_head
+    { };
+struct dual_seekable
+    : virtual input_seekable,
+      virtual output_seekable,
+      detail::two_head
+    { };
+struct bidirectional_seekable
+    : input_seekable, output_seekable,
+      bidirectional, detail::two_head
+    { };
+struct device_tag : virtual any_tag { };
+struct filter_tag : virtual any_tag { };
+struct peekable_tag : virtual any_tag { };
+struct closable_tag : virtual any_tag { };
+struct flushable_tag : virtual any_tag { };
+struct localizable_tag : virtual any_tag { };
+struct optimally_buffered_tag : virtual any_tag { };
+struct direct_tag : virtual any_tag { };
+struct multichar_tag : virtual any_tag { };
+struct source_tag : device_tag, input { };
+struct sink_tag : device_tag, output { };
+struct bidirectional_device_tag : device_tag, bidirectional { };
+struct seekable_device_tag : virtual device_tag, seekable { };
+struct input_filter_tag : filter_tag, input { };
+struct output_filter_tag : filter_tag, output { };
+struct bidirectional_filter_tag : filter_tag, bidirectional { };
+struct seekable_filter_tag : filter_tag, seekable { };
+struct dual_use_filter_tag : filter_tag, dual_use { };
+struct multichar_input_filter_tag
+    : multichar_tag,
+      input_filter_tag
+    { };
+struct multichar_output_filter_tag
+    : multichar_tag,
+      output_filter_tag
+    { };
+struct multichar_bidirectional_filter_tag
+    : multichar_tag,
+      bidirectional_filter_tag
+    { };
+struct multichar_seekable_filter_tag
+    : multichar_tag,
+      seekable_filter_tag
+    { };
+struct multichar_dual_use_filter_tag
+    : multichar_tag,
+      dual_use_filter_tag
+    { };
+struct std_io_tag : virtual localizable_tag { };
+struct istream_tag
+    : virtual device_tag,
+      virtual peekable_tag,
+      virtual std_io_tag
+    { };
+struct ostream_tag
+    : virtual device_tag,
+      virtual std_io_tag
+    { };
+struct iostream_tag
+    : istream_tag,
+      ostream_tag
+    { };
+struct streambuf_tag
+    : device_tag,
+      peekable_tag,
+      std_io_tag
+    { };
+struct ifstream_tag
+    : input_seekable,
+      closable_tag,
+      istream_tag
+    { };
+struct ofstream_tag
+    : output_seekable,
+      closable_tag,
+      ostream_tag
+    { };
+struct fstream_tag
+    : seekable,
+      closable_tag,
+      iostream_tag
+    { };
+struct filebuf_tag
+    : seekable,
+      closable_tag,
+      streambuf_tag
+    { };
+struct istringstream_tag
+    : input_seekable,
+      istream_tag
+    { };
+struct ostringstream_tag
+    : output_seekable,
+      ostream_tag
+    { };
+struct stringstream_tag
+    : dual_seekable,
+      iostream_tag
+    { };
+struct stringbuf_tag
+    : dual_seekable,
+      streambuf_tag
+    { };
+struct generic_istream_tag
+    : input_seekable,
+      istream_tag
+    { };
+struct generic_ostream_tag
+    : output_seekable,
+      ostream_tag
+    { };
+struct generic_iostream_tag
+    : seekable,
+      iostream_tag
+    { };
+struct generic_streambuf_tag
+    : seekable,
+      streambuf_tag
+    { };
+} }
+namespace boost {
+template<typename Iterator>
+class iterator_range;
+namespace iostreams {
+namespace is_iterator_range_impl_ { template< typename T0 > type_traits::yes_type helper (const volatile boost::iterator_range < T0 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_iterator_range_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_iterator_range : mpl::bool_<is_iterator_range_impl_::impl<T>::value> { };
+}
+}
+namespace boost { namespace iostreams { namespace detail {
+template<int N> struct case_ { char c1; case_<N - 1> c2; };
+template<> struct case_<-1> { char c; };
+typedef case_<true> yes_type;
+typedef case_<false> no_type;
+template<unsigned Size> struct select_by_size;
+} } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_0 = sizeof(case_<0 - 1>); template<> struct select_by_size< sizeof_case_0 > { struct type { static const int value = 0 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_1 = sizeof(case_<1 - 1>); template<> struct select_by_size< sizeof_case_1 > { struct type { static const int value = 1 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_2 = sizeof(case_<2 - 1>); template<> struct select_by_size< sizeof_case_2 > { struct type { static const int value = 2 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_3 = sizeof(case_<3 - 1>); template<> struct select_by_size< sizeof_case_3 > { struct type { static const int value = 3 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_4 = sizeof(case_<4 - 1>); template<> struct select_by_size< sizeof_case_4 > { struct type { static const int value = 4 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_5 = sizeof(case_<5 - 1>); template<> struct select_by_size< sizeof_case_5 > { struct type { static const int value = 5 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_6 = sizeof(case_<6 - 1>); template<> struct select_by_size< sizeof_case_6 > { struct type { static const int value = 6 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_7 = sizeof(case_<7 - 1>); template<> struct select_by_size< sizeof_case_7 > { struct type { static const int value = 7 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_8 = sizeof(case_<8 - 1>); template<> struct select_by_size< sizeof_case_8 > { struct type { static const int value = 8 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_9 = sizeof(case_<9 - 1>); template<> struct select_by_size< sizeof_case_9 > { struct type { static const int value = 9 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_10 = sizeof(case_<10 - 1>); template<> struct select_by_size< sizeof_case_10 > { struct type { static const int value = 10 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_11 = sizeof(case_<11 - 1>); template<> struct select_by_size< sizeof_case_11 > { struct type { static const int value = 11 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_12 = sizeof(case_<12 - 1>); template<> struct select_by_size< sizeof_case_12 > { struct type { static const int value = 12 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_13 = sizeof(case_<13 - 1>); template<> struct select_by_size< sizeof_case_13 > { struct type { static const int value = 13 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_14 = sizeof(case_<14 - 1>); template<> struct select_by_size< sizeof_case_14 > { struct type { static const int value = 14 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_15 = sizeof(case_<15 - 1>); template<> struct select_by_size< sizeof_case_15 > { struct type { static const int value = 15 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_16 = sizeof(case_<16 - 1>); template<> struct select_by_size< sizeof_case_16 > { struct type { static const int value = 16 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_17 = sizeof(case_<17 - 1>); template<> struct select_by_size< sizeof_case_17 > { struct type { static const int value = 17 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_18 = sizeof(case_<18 - 1>); template<> struct select_by_size< sizeof_case_18 > { struct type { static const int value = 18 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_19 = sizeof(case_<19 - 1>); template<> struct select_by_size< sizeof_case_19 > { struct type { static const int value = 19 - 1; }; static const int value = type::value; }; } } }
+        namespace boost { namespace iostreams { namespace detail { static const int sizeof_case_20 = sizeof(case_<20 - 1>); template<> struct select_by_size< sizeof_case_20 > { struct type { static const int value = 20 - 1; }; static const int value = type::value; }; } } }
+namespace boost { namespace iostreams {
+template<typename T>
+struct is_istream;
+template<typename T>
+struct is_ostream;
+template<typename T>
+struct is_iostream;
+template<typename T>
+struct is_streambuf;
+template<typename T>
+struct is_istringstream;
+template<typename T>
+struct is_ostringstream;
+template<typename T>
+struct is_stringstream;
+template<typename T>
+struct is_stringbuf;
+template<typename T>
+struct is_ifstream;
+template<typename T>
+struct is_ofstream;
+template<typename T>
+struct is_fstream;
+template<typename T>
+struct is_filebuf;
+template<typename T>
+struct is_std_io;
+template<typename T>
+struct is_std_file_device;
+template<typename T>
+struct is_std_string_device;
+template<typename T>
+struct char_type_of;
+template<typename T>
+struct category_of;
+template<typename T>
+struct int_type_of;
+template<typename T>
+struct mode_of;
+template<typename T>
+struct is_device;
+template<typename T>
+struct is_filter;
+template<typename T>
+struct is_direct;
+namespace detail {
+template<typename T>
+struct is_boost_stream;
+template<typename T>
+struct is_boost_stream_buffer;
+template<typename T>
+struct is_filtering_stream;
+template<typename T>
+struct is_filtering_streambuf;
+template<typename T>
+struct is_linked;
+template<typename T>
+struct is_boost;
+}
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T>
+struct wrapped_type
+    : mpl::if_<is_std_io<T>, reference_wrapper<T>, T>
+    { };
+template<typename T>
+struct unwrapped_type
+    : unwrap_reference<T>
+    { };
+template<typename T>
+struct unwrap_ios
+    : mpl::eval_if<
+          is_std_io<T>,
+          unwrap_reference<T>,
+          mpl::identity<T>
+      >
+    { };
+    template<typename T>
+    inline T wrap(const T& t , typename boost::disable_if< boost::iostreams::is_std_io<T> >::type* = 0)
+    { return t; }
+    template<typename T>
+    inline typename wrapped_type<T>::type
+    wrap(T& t , typename boost::enable_if< boost::iostreams::is_std_io<T> >::type* = 0) { return boost::ref(t); }
+template<typename T>
+typename unwrapped_type<T>::type&
+unwrap(const reference_wrapper<T>& ref) { return ref.get(); }
+template<typename T>
+typename unwrapped_type<T>::type& unwrap(T& t) { return t; }
+template<typename T>
+const typename unwrapped_type<T>::type& unwrap(const T& t) { return t; }
+} } }
+namespace boost { namespace iostreams {
+namespace is_istream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_istream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_istream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_istream : mpl::bool_<is_istream_impl_::impl<T>::value> { };
+namespace is_ostream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_ostream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_ostream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_ostream : mpl::bool_<is_ostream_impl_::impl<T>::value> { };
+namespace is_iostream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_iostream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_iostream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_iostream : mpl::bool_<is_iostream_impl_::impl<T>::value> { };
+namespace is_streambuf_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_streambuf < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_streambuf_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_streambuf : mpl::bool_<is_streambuf_impl_::impl<T>::value> { };
+namespace is_ifstream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_ifstream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_ifstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_ifstream : mpl::bool_<is_ifstream_impl_::impl<T>::value> { };
+namespace is_ofstream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_ofstream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_ofstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_ofstream : mpl::bool_<is_ofstream_impl_::impl<T>::value> { };
+namespace is_fstream_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_fstream < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_fstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_fstream : mpl::bool_<is_fstream_impl_::impl<T>::value> { };
+namespace is_filebuf_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile std::basic_filebuf < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_filebuf_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_filebuf : mpl::bool_<is_filebuf_impl_::impl<T>::value> { };
+namespace is_istringstream_impl_ { template< typename T0 , typename T1 , typename T2 > type_traits::yes_type helper (const volatile std::basic_istringstream < T0 , T1 , T2 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_istringstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_istringstream : mpl::bool_<is_istringstream_impl_::impl<T>::value> { };
+namespace is_ostringstream_impl_ { template< typename T0 , typename T1 , typename T2 > type_traits::yes_type helper (const volatile std::basic_ostringstream < T0 , T1 , T2 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_ostringstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_ostringstream : mpl::bool_<is_ostringstream_impl_::impl<T>::value> { };
+namespace is_stringstream_impl_ { template< typename T0 , typename T1 , typename T2 > type_traits::yes_type helper (const volatile std::basic_stringstream < T0 , T1 , T2 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_stringstream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_stringstream : mpl::bool_<is_stringstream_impl_::impl<T>::value> { };
+namespace is_stringbuf_impl_ { template< typename T0 , typename T1 , typename T2 > type_traits::yes_type helper (const volatile std::basic_stringbuf < T0 , T1 , T2 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_stringbuf_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_stringbuf : mpl::bool_<is_stringbuf_impl_::impl<T>::value> { };
+template<typename T>
+struct is_std_io
+    : mpl::or_< is_istream<T>, is_ostream<T>, is_streambuf<T> >
+    { };
+template<typename T>
+struct is_std_file_device
+    : mpl::or_<
+          is_ifstream<T>,
+          is_ofstream<T>,
+          is_fstream<T>,
+          is_filebuf<T>
+      >
+    { };
+template<typename T>
+struct is_std_string_device
+    : mpl::or_<
+          is_istringstream<T>,
+          is_ostringstream<T>,
+          is_stringstream<T>,
+          is_stringbuf<T>
+      >
+    { };
+template<typename Device, typename Tr, typename Alloc>
+struct stream;
+template<typename T, typename Tr, typename Alloc, typename Mode>
+class stream_buffer;
+template< typename Mode, typename Ch, typename Tr,
+          typename Alloc, typename Access >
+class filtering_stream;
+template< typename Mode, typename Ch, typename Tr,
+          typename Alloc, typename Access >
+class wfiltering_stream;
+template< typename Mode, typename Ch, typename Tr,
+          typename Alloc, typename Access >
+class filtering_streambuf;
+template< typename Mode, typename Ch, typename Tr,
+          typename Alloc, typename Access >
+class filtering_wstreambuf;
+namespace detail {
+template<typename T, typename Tr>
+class linked_streambuf;
+namespace
+ is_boost_stream_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 > type_traits::yes_type helper (const volatile boost::iostreams::stream < T0 , T1 , T2 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_boost_stream_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_boost_stream : mpl::bool_<is_boost_stream_impl_::impl<T>::value> { };
+namespace
+ is_boost_stream_buffer_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 , typename T3 > type_traits::yes_type helper (const volatile boost::iostreams::stream_buffer < T0 , T1 , T2 , T3 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_boost_stream_buffer_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_boost_stream_buffer : mpl::bool_<is_boost_stream_buffer_impl_::impl<T>::value> { };
+namespace
+ is_filtering_stream_impl_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > type_traits::yes_type helper (const volatile boost::iostreams::filtering_stream < T0 , T1 , T2 , T3 , T4 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_filtering_stream_impl_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_filtering_stream_impl : mpl::bool_<is_filtering_stream_impl_impl_::impl<T>::value> { };
+namespace
+ is_filtering_wstream_impl_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > type_traits::yes_type helper (const volatile boost::iostreams::wfiltering_stream < T0 , T1 , T2 , T3 , T4 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_filtering_wstream_impl_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_filtering_wstream_impl : mpl::bool_<is_filtering_wstream_impl_impl_::impl<T>::value> { };
+namespace
+ is_filtering_streambuf_impl_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > type_traits::yes_type helper (const volatile boost::iostreams::filtering_streambuf < T0 , T1 , T2 , T3 , T4 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_filtering_streambuf_impl_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_filtering_streambuf_impl : mpl::bool_<is_filtering_streambuf_impl_impl_::impl<T>::value> { };
+namespace
+ is_filtering_wstreambuf_impl_impl_
+ {
+ template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > type_traits::yes_type helper (const volatile boost::iostreams::filtering_wstreambuf < T0 , T1 , T2 , T3 , T4 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_filtering_wstreambuf_impl_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_filtering_wstreambuf_impl : mpl::bool_<is_filtering_wstreambuf_impl_impl_::impl<T>::value> { };
+namespace is_linked_impl_ { template< typename T0 , typename T1 > type_traits::yes_type helper (const volatile linked_streambuf < T0 , T1 >*); type_traits::no_type helper(...); template<typename T> struct impl { static const bool value = (sizeof(is_linked_impl_:: helper(static_cast<T*>(0))) == sizeof(type_traits::yes_type)); }; } template<typename T> struct is_linked : mpl::bool_<is_linked_impl_::impl<T>::value> { };
+template<typename T>
+struct is_filtering_stream
+    : mpl::or_<
+          is_filtering_stream_impl<T>,
+          is_filtering_wstream_impl<T>
+      >
+    { };
+template<typename T>
+struct is_filtering_streambuf
+    : mpl::or_<
+          is_filtering_streambuf_impl<T>,
+          is_filtering_wstreambuf_impl<T>
+      >
+    { };
+template<typename T>
+struct is_boost
+    : mpl::or_<
+          is_boost_stream<T>,
+          is_boost_stream_buffer<T>,
+          is_filtering_stream<T>,
+          is_filtering_streambuf<T>
+      >
+    { };
+}
+namespace detail {
+template<typename T>
+struct member_char_type { typedef typename T::char_type type; };
+}
+template<typename T>
+struct char_type_of
+    : detail::member_char_type<
+          typename detail::unwrapped_type<T>::type
+      >
+    { };
+template<typename Iter>
+struct char_type_of< iterator_range<Iter> > {
+    typedef typename iterator_value<Iter>::type type;
+};
+namespace detail {
+template<typename T>
+struct member_category { typedef typename T::category type; };
+}
+template<typename T>
+struct category_of {
+    template<typename U>
+    struct member_category {
+        typedef typename U::category type;
+    };
+    typedef typename detail::unwrapped_type<T>::type U;
+    typedef typename
+            mpl::eval_if<
+                mpl::and_<
+                    is_std_io<U>,
+                    mpl::not_< detail::is_boost<U> >
+                >,
+                iostreams::select<
+                    is_filebuf<U>, filebuf_tag,
+                    is_ifstream<U>, ifstream_tag,
+                    is_ofstream<U>, ofstream_tag,
+                    is_fstream<U>, fstream_tag,
+                    is_stringbuf<U>, stringbuf_tag,
+                    is_istringstream<U>, istringstream_tag,
+                    is_ostringstream<U>, ostringstream_tag,
+                    is_stringstream<U>, stringstream_tag,
+                    is_streambuf<U>, generic_streambuf_tag,
+                    is_iostream<U>, generic_iostream_tag,
+                    is_istream<U>, generic_istream_tag,
+                    is_ostream<U>, generic_ostream_tag
+                >,
+                detail::member_category<U>
+            >::type type;
+};
+template<typename T>
+struct category_of< reference_wrapper<T> >
+    : category_of<T>
+    { };
+template<typename T>
+inline typename category_of<T>::type get_category(const T&)
+{ typedef typename category_of<T>::type category; return category(); }
+template<typename T>
+struct int_type_of {
+    typedef std::char_traits<
+                typename char_type_of<T>::type
+            > traits_type;
+    typedef typename traits_type::int_type type;
+};
+namespace detail {
+template<int N> struct io_mode_impl;
+case_<1> io_mode_impl_helper(input); template<> struct io_mode_impl<1> { typedef input type; };
+case_<2> io_mode_impl_helper(output); template<> struct io_mode_impl<2> { typedef output type; };
+case_<3> io_mode_impl_helper(bidirectional); template<> struct io_mode_impl<3> { typedef bidirectional type; };
+case_<4> io_mode_impl_helper(input_seekable); template<> struct io_mode_impl<4> { typedef input_seekable type; };
+case_<5> io_mode_impl_helper(output_seekable); template<> struct io_mode_impl<5> { typedef output_seekable type; };
+case_<6> io_mode_impl_helper(seekable); template<> struct io_mode_impl<6> { typedef seekable type; };
+case_<7> io_mode_impl_helper(dual_seekable); template<> struct io_mode_impl<7> { typedef dual_seekable type; };
+case_<8> io_mode_impl_helper(bidirectional_seekable); template<> struct io_mode_impl<8> { typedef bidirectional_seekable type; };
+case_<9> io_mode_impl_helper(dual_use); template<> struct io_mode_impl<9> { typedef dual_use type; };
+template<typename T>
+struct io_mode_id {
+    typedef typename category_of<T>::type category;
+    static const unsigned boost_select_by_size_temp_value = sizeof(detail::io_mode_impl_helper(category())); static const int value = ( ::boost::iostreams::detail::select_by_size< boost_select_by_size_temp_value >::value );
+};
+}
+template<typename T>
+struct mode_of : detail::io_mode_impl< detail::io_mode_id<T>::value > { };
+template<typename T>
+struct mode_of< reference_wrapper<T> >
+    : mode_of<T>
+    { };
+namespace detail {
+template<typename T, typename Tag>
+struct has_trait_impl {
+    typedef typename category_of<T>::type category;
+    static const bool value = (is_convertible<category, Tag>::value);
+};
+template<typename T, typename Tag>
+struct has_trait
+    : mpl::bool_<has_trait_impl<T, Tag>::value>
+    { };
+}
+template<typename T>
+struct is_device : detail::has_trait<T, device_tag> { };
+template<typename T>
+struct is_filter : detail::has_trait<T, filter_tag> { };
+template<typename T>
+struct is_direct : detail::has_trait<T, direct_tag> { };
+} }
+namespace boost { namespace iostreams {namespace detail {
+template< typename T, typename Tag1, typename Tag2,
+          typename Tag3 = mpl::void_, typename Tag4 = mpl::void_,
+          typename Tag5 = mpl::void_, typename Tag6 = mpl::void_,
+          typename Category =
+              typename category_of<T>::type >
+struct dispatch
+    : iostreams::select<
+          is_convertible<Category, Tag1>, Tag1,
+          is_convertible<Category, Tag2>, Tag2,
+          is_convertible<Category, Tag3>, Tag3,
+          is_convertible<Category, Tag4>, Tag4,
+          is_convertible<Category, Tag5>, Tag5,
+          is_convertible<Category, Tag6>, Tag6
+      >
+    { };
+} } }
+namespace boost { namespace iostreams {
+template<typename T>
+struct operations;
+namespace detail {
+struct custom_tag { };
+template<typename T>
+struct is_custom
+    : mpl::not_<
+          is_base_and_derived< custom_tag, operations<T> >
+      >
+    { };
+}
+template<typename T>
+struct operations : detail::custom_tag { };
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct flush_device_impl;
+template<typename T>
+struct flush_filter_impl;
+}
+template<typename T>
+bool flush(T& t)
+{ return detail::flush_device_impl<T>::flush(detail::unwrap(t)); }
+template<typename T, typename Sink>
+bool flush(T& t, Sink& snk)
+{ return detail::flush_filter_impl<T>::flush(detail::unwrap(t), snk); }
+namespace detail {
+template<typename T>
+struct flush_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          flush_device_impl<
+              typename
+              dispatch<
+                  T, ostream_tag, streambuf_tag, flushable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct flush_device_impl<ostream_tag> {
+    template<typename T>
+    static bool flush(T& t)
+    { return t.rdbuf()->pubsync() == 0; }
+};
+template<>
+struct flush_device_impl<streambuf_tag> {
+    template<typename T>
+    static bool flush(T& t)
+    { return t.pubsync() == 0; }
+};
+template<>
+struct flush_device_impl<flushable_tag> {
+    template<typename T>
+    static bool flush(T& t) { return t.flush(); }
+};
+template<>
+struct flush_device_impl<any_tag> {
+    template<typename T>
+    static bool flush(T&) { return true; }
+};
+template<typename T>
+struct flush_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          flush_filter_impl<
+              typename
+              dispatch<
+                  T, flushable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct flush_filter_impl<flushable_tag> {
+    template<typename T, typename Sink>
+    static bool flush(T& t, Sink& snk) { return t.flush(snk); }
+};
+template<>
+struct flush_filter_impl<any_tag> {
+    template<typename T, typename Sink>
+    static bool flush(T&, Sink&) { return false; }
+};
+}
+} }
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+  using ::gets;
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+  using ::tmpnam;
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+}
+namespace __gnu_cxx
+{
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+}
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+}
+namespace boost { namespace iostreams {
+const int WOULD_BLOCK = (int) ((-1) - 1);
+const std::wint_t WWOULD_BLOCK = (std::wint_t) ((0xffffffffu) - 1);
+template<typename Ch>
+struct char_traits;
+template<>
+struct char_traits<char> : std::char_traits< char > {
+    static char newline() { return '\n'; }
+    static int good() { return '\n'; }
+    static int would_block() { return WOULD_BLOCK; }
+    static bool is_good(int c) { return c != (-1) && c != WOULD_BLOCK; }
+    static bool is_eof(int c) { return c == (-1); }
+    static bool would_block(int c) { return c == WOULD_BLOCK; }
+};
+template<>
+struct char_traits<wchar_t> : std::char_traits<wchar_t> {
+    static wchar_t newline() { return L'\n'; }
+    static std::wint_t good() { return L'\n'; }
+    static std::wint_t would_block() { return WWOULD_BLOCK; }
+    static bool is_good(std::wint_t c) { return c != (0xffffffffu) && c != WWOULD_BLOCK; }
+    static bool is_eof(std::wint_t c) { return c == (0xffffffffu); }
+    static bool would_block(std::wint_t c) { return c == WWOULD_BLOCK; }
+};
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct read_device_impl;
+template<typename T>
+struct read_filter_impl;
+}
+template<typename T>
+typename int_type_of<T>::type get(T& t)
+{ return detail::read_device_impl<T>::get(detail::unwrap(t)); }
+template<typename T>
+inline std::streamsize
+read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::read_device_impl<T>::read(detail::unwrap(t), s, n); }
+template<typename T, typename Source>
+std::streamsize
+read(T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::read_filter_impl<T>::read(detail::unwrap(t), src, s, n); }
+template<typename T>
+bool putback(T& t, typename char_type_of<T>::type c)
+{ return detail::read_device_impl<T>::putback(detail::unwrap(t), c); }
+namespace detail {
+inline std::streamsize check_eof(std::streamsize n) { return n != 0 ? n : -1; }
+template<bool IsLinked>
+struct true_eof_impl;
+template<>
+struct true_eof_impl<true> {
+    template<typename T>
+    static bool true_eof(T& t) { return t.true_eof(); }
+};
+template<>
+struct true_eof_impl<false> {
+    template<typename T>
+    static bool true_eof(T&) { return true; }
+};
+template<typename T>
+inline bool true_eof(T& t)
+{
+    const bool linked = is_linked<T>::value;
+    return true_eof_impl<linked>::true_eof(t);
+}
+template<typename T>
+struct read_device_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          read_device_impl<
+              typename
+              detail::dispatch<
+                  T, istream_tag, streambuf_tag, input
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct read_device_impl<istream_tag> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T& t)
+    { return t.get(); }
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return check_eof(t.rdbuf()->sgetn(s, n)); }
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef std::char_traits< char_type > traits_type;
+        return !traits_type::eq_int_type( t.rdbuf()->sputbackc(c),
+                                          traits_type::eof() );
+    }
+};
+template<>
+struct read_device_impl<streambuf_tag> {
+    template<typename T>
+    static typename int_type_of<T>::type
+    get(T& t)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef iostreams::char_traits<char_type> traits_type;
+        typename int_type_of<T>::type c;
+        return !traits_type::is_eof(c = t.sbumpc()) ||
+                detail::true_eof(t)
+                    ?
+                c : traits_type::would_block();
+    }
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    {
+        std::streamsize amt;
+        return (amt = t.sgetn(s, n)) != 0 ?
+            amt :
+            detail::true_eof(t) ?
+                -1 :
+                0;
+    }
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef iostreams::char_traits<char_type> traits_type;
+        return !traits_type::is_eof(t.sputbackc(c));
+    }
+};
+template<>
+struct read_device_impl<input> {
+    template<typename T>
+    static typename int_type_of<T>::type
+    get(T& t)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef iostreams::char_traits<char_type> traits_type;
+        char_type c;
+        std::streamsize amt;
+        return (amt = t.read(&c, 1)) == 1 ?
+            traits_type::to_int_type(c) :
+            amt == -1 ?
+                traits_type::eof() :
+                traits_type::would_block();
+    }
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.read(s, n); }
+    template<typename T>
+    static bool putback(T& t, typename char_type_of<T>::type c)
+    {
+        return t.putback(c);
+    }
+};
+template<typename T>
+struct read_filter_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          read_filter_impl<
+              typename
+              detail::dispatch<
+                  T, multichar_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct read_filter_impl<multichar_tag> {
+    template<typename T, typename Source>
+    static std::streamsize read
+       (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.read(src, s, n); }
+};
+template<>
+struct read_filter_impl<any_tag> {
+    template<typename T, typename Source>
+    static std::streamsize read
+       (T& t, Source& src, typename char_type_of<T>::type* s, std::streamsize n)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef iostreams::char_traits<char_type> traits_type;
+        for (std::streamsize off = 0; off < n; ++off) {
+            typename traits_type::int_type c = t.get(src);
+            if (traits_type::is_eof(c))
+                return check_eof(off);
+            if (traits_type::would_block(c))
+                return off;
+            s[off] = traits_type::to_char_type(c);
+        }
+        return n;
+    }
+};
+}
+} }
+namespace std
+{
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class time_base
+  {
+  public:
+    enum dateorder { no_order, dmy, mdy, ymd, ydm };
+  };
+  template<typename _CharT>
+    struct __timepunct_cache : public locale::facet
+    {
+      static const _CharT* _S_timezones[14];
+      const _CharT* _M_date_format;
+      const _CharT* _M_date_era_format;
+      const _CharT* _M_time_format;
+      const _CharT* _M_time_era_format;
+      const _CharT* _M_date_time_format;
+      const _CharT* _M_date_time_era_format;
+      const _CharT* _M_am;
+      const _CharT* _M_pm;
+      const _CharT* _M_am_pm_format;
+      const _CharT* _M_day1;
+      const _CharT* _M_day2;
+      const _CharT* _M_day3;
+      const _CharT* _M_day4;
+      const _CharT* _M_day5;
+      const _CharT* _M_day6;
+      const _CharT* _M_day7;
+      const _CharT* _M_aday1;
+      const _CharT* _M_aday2;
+      const _CharT* _M_aday3;
+      const _CharT* _M_aday4;
+      const _CharT* _M_aday5;
+      const _CharT* _M_aday6;
+      const _CharT* _M_aday7;
+      const _CharT* _M_month01;
+      const _CharT* _M_month02;
+      const _CharT* _M_month03;
+      const _CharT* _M_month04;
+      const _CharT* _M_month05;
+      const _CharT* _M_month06;
+      const _CharT* _M_month07;
+      const _CharT* _M_month08;
+      const _CharT* _M_month09;
+      const _CharT* _M_month10;
+      const _CharT* _M_month11;
+      const _CharT* _M_month12;
+      const _CharT* _M_amonth01;
+      const _CharT* _M_amonth02;
+      const _CharT* _M_amonth03;
+      const _CharT* _M_amonth04;
+      const _CharT* _M_amonth05;
+      const _CharT* _M_amonth06;
+      const _CharT* _M_amonth07;
+      const _CharT* _M_amonth08;
+      const _CharT* _M_amonth09;
+      const _CharT* _M_amonth10;
+      const _CharT* _M_amonth11;
+      const _CharT* _M_amonth12;
+      bool _M_allocated;
+      __timepunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
+      _M_time_era_format(0), _M_date_time_format(0),
+      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
+      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
+      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
+      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
+      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
+      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
+      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
+      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
+      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
+      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
+      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
+      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
+      { }
+      ~__timepunct_cache();
+      void
+      _M_cache(const locale& __loc);
+    private:
+      __timepunct_cache&
+      operator=(const __timepunct_cache&);
+      explicit
+      __timepunct_cache(const __timepunct_cache&);
+    };
+  template<typename _CharT>
+    __timepunct_cache<_CharT>::~__timepunct_cache()
+    {
+      if (_M_allocated)
+ {
+ }
+    }
+  template<>
+    const char*
+    __timepunct_cache<char>::_S_timezones[14];
+  template<>
+    const wchar_t*
+    __timepunct_cache<wchar_t>::_S_timezones[14];
+  template<typename _CharT>
+    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
+  template<typename _CharT>
+    class __timepunct : public locale::facet
+    {
+    public:
+      typedef _CharT __char_type;
+      typedef basic_string<_CharT> __string_type;
+      typedef __timepunct_cache<_CharT> __cache_type;
+    protected:
+      __cache_type* _M_data;
+      __c_locale _M_c_locale_timepunct;
+      const char* _M_name_timepunct;
+    public:
+      static locale::id id;
+      explicit
+      __timepunct(size_t __refs = 0);
+      explicit
+      __timepunct(__cache_type* __cache, size_t __refs = 0);
+      explicit
+      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
+      void
+      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
+      const tm* __tm) const throw ();
+      void
+      _M_date_formats(const _CharT** __date) const
+      {
+ __date[0] = _M_data->_M_date_format;
+ __date[1] = _M_data->_M_date_era_format;
+      }
+      void
+      _M_time_formats(const _CharT** __time) const
+      {
+ __time[0] = _M_data->_M_time_format;
+ __time[1] = _M_data->_M_time_era_format;
+      }
+      void
+      _M_date_time_formats(const _CharT** __dt) const
+      {
+ __dt[0] = _M_data->_M_date_time_format;
+ __dt[1] = _M_data->_M_date_time_era_format;
+      }
+      void
+      _M_am_pm_format(const _CharT* __ampm) const
+      { __ampm = _M_data->_M_am_pm_format; }
+      void
+      _M_am_pm(const _CharT** __ampm) const
+      {
+ __ampm[0] = _M_data->_M_am;
+ __ampm[1] = _M_data->_M_pm;
+      }
+      void
+      _M_days(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_day1;
+ __days[1] = _M_data->_M_day2;
+ __days[2] = _M_data->_M_day3;
+ __days[3] = _M_data->_M_day4;
+ __days[4] = _M_data->_M_day5;
+ __days[5] = _M_data->_M_day6;
+ __days[6] = _M_data->_M_day7;
+      }
+      void
+      _M_days_abbreviated(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_aday1;
+ __days[1] = _M_data->_M_aday2;
+ __days[2] = _M_data->_M_aday3;
+ __days[3] = _M_data->_M_aday4;
+ __days[4] = _M_data->_M_aday5;
+ __days[5] = _M_data->_M_aday6;
+ __days[6] = _M_data->_M_aday7;
+      }
+      void
+      _M_months(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_month01;
+ __months[1] = _M_data->_M_month02;
+ __months[2] = _M_data->_M_month03;
+ __months[3] = _M_data->_M_month04;
+ __months[4] = _M_data->_M_month05;
+ __months[5] = _M_data->_M_month06;
+ __months[6] = _M_data->_M_month07;
+ __months[7] = _M_data->_M_month08;
+ __months[8] = _M_data->_M_month09;
+ __months[9] = _M_data->_M_month10;
+ __months[10] = _M_data->_M_month11;
+ __months[11] = _M_data->_M_month12;
+      }
+      void
+      _M_months_abbreviated(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_amonth01;
+ __months[1] = _M_data->_M_amonth02;
+ __months[2] = _M_data->_M_amonth03;
+ __months[3] = _M_data->_M_amonth04;
+ __months[4] = _M_data->_M_amonth05;
+ __months[5] = _M_data->_M_amonth06;
+ __months[6] = _M_data->_M_amonth07;
+ __months[7] = _M_data->_M_amonth08;
+ __months[8] = _M_data->_M_amonth09;
+ __months[9] = _M_data->_M_amonth10;
+ __months[10] = _M_data->_M_amonth11;
+ __months[11] = _M_data->_M_amonth12;
+      }
+    protected:
+      virtual
+      ~__timepunct();
+      void
+      _M_initialize_timepunct(__c_locale __cloc = 0);
+    };
+  template<typename _CharT>
+    locale::id __timepunct<_CharT>::id;
+  template<>
+    void
+    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
+  template<>
+    void
+    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
+  template<>
+    void
+    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
+  template<>
+    void
+    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
+     const tm*) const throw ();
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
+    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
+         size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(0)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_timepunct = __tmp;
+ }
+      else
+ _M_name_timepunct = _S_get_c_name();
+      try
+ { _M_initialize_timepunct(__cloc); }
+      catch(...)
+ {
+   if (_M_name_timepunct != _S_get_c_name())
+     delete [] _M_name_timepunct;
+   throw;
+ }
+    }
+  template<typename _CharT>
+    __timepunct<_CharT>::~__timepunct()
+    {
+      if (_M_name_timepunct != _S_get_c_name())
+ delete [] _M_name_timepunct;
+      delete _M_data;
+      _S_destroy_c_locale(_M_c_locale_timepunct);
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, typename _InIter>
+    class time_get : public locale::facet, public time_base
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      typedef basic_string<_CharT> __string_type;
+      static locale::id id;
+      explicit
+      time_get(size_t __refs = 0)
+      : facet (__refs) { }
+      dateorder
+      date_order() const
+      { return this->do_date_order(); }
+      iter_type
+      get_time(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
+      iter_type
+      get_date(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
+      iter_type
+      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
+      iter_type
+      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
+      iter_type
+      get_year(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
+    protected:
+      virtual
+      ~time_get() { }
+      virtual dateorder
+      do_date_order() const;
+      virtual iter_type
+      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+      virtual iter_type
+      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+      virtual iter_type
+      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
+       ios_base::iostate& __err, tm* __tm) const;
+      virtual iter_type
+      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
+         ios_base::iostate& __err, tm* __tm) const;
+      virtual iter_type
+      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+      iter_type
+      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+       int __min, int __max, size_t __len,
+       ios_base& __io, ios_base::iostate& __err) const;
+      iter_type
+      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const;
+      iter_type
+      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+          const _CharT** __names, size_t __indexlen,
+          ios_base& __io, ios_base::iostate& __err) const;
+      iter_type
+      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+       ios_base::iostate& __err, tm* __tm,
+       const _CharT* __format) const;
+    };
+  template<typename _CharT, typename _InIter>
+    locale::id time_get<_CharT, _InIter>::id;
+  template<typename _CharT, typename _InIter>
+    class time_get_byname : public time_get<_CharT, _InIter>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      explicit
+      time_get_byname(const char*, size_t __refs = 0)
+      : time_get<_CharT, _InIter>(__refs) { }
+    protected:
+      virtual
+      ~time_get_byname() { }
+    };
+  template<typename _CharT, typename _OutIter>
+    class time_put : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      static locale::id id;
+      explicit
+      time_put(size_t __refs = 0)
+      : facet(__refs) { }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+   const _CharT* __beg, const _CharT* __end) const;
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const tm* __tm, char __format, char __mod = 0) const
+      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
+    protected:
+      virtual
+      ~time_put()
+      { }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+      char __format, char __mod) const;
+    };
+  template<typename _CharT, typename _OutIter>
+    locale::id time_put<_CharT, _OutIter>::id;
+  template<typename _CharT, typename _OutIter>
+    class time_put_byname : public time_put<_CharT, _OutIter>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      explicit
+      time_put_byname(const char*, size_t __refs = 0)
+      : time_put<_CharT, _OutIter>(__refs)
+      { };
+    protected:
+      virtual
+      ~time_put_byname() { }
+    };
+  class money_base
+  {
+  public:
+    enum part { none, space, symbol, sign, value };
+    struct pattern { char field[4]; };
+    static const pattern _S_default_pattern;
+    enum
+    {
+      _S_minus,
+      _S_zero,
+      _S_end = 11
+    };
+    static const char* _S_atoms;
+    __attribute__ ((__const__)) static pattern
+    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
+  };
+  template<typename _CharT, bool _Intl>
+    struct __moneypunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      const _CharT* _M_curr_symbol;
+      size_t _M_curr_symbol_size;
+      const _CharT* _M_positive_sign;
+      size_t _M_positive_sign_size;
+      const _CharT* _M_negative_sign;
+      size_t _M_negative_sign_size;
+      int _M_frac_digits;
+      money_base::pattern _M_pos_format;
+      money_base::pattern _M_neg_format;
+      _CharT _M_atoms[money_base::_S_end];
+      bool _M_allocated;
+      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
+      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
+      _M_curr_symbol(0), _M_curr_symbol_size(0),
+      _M_positive_sign(0), _M_positive_sign_size(0),
+      _M_negative_sign(0), _M_negative_sign_size(0),
+      _M_frac_digits(0),
+      _M_pos_format(money_base::pattern()),
+      _M_neg_format(money_base::pattern()), _M_allocated(false)
+      { }
+      ~__moneypunct_cache();
+      void
+      _M_cache(const locale& __loc);
+    private:
+      __moneypunct_cache&
+      operator=(const __moneypunct_cache&);
+      explicit
+      __moneypunct_cache(const __moneypunct_cache&);
+    };
+  template<typename _CharT, bool _Intl>
+    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_curr_symbol;
+   delete [] _M_positive_sign;
+   delete [] _M_negative_sign;
+ }
+    }
+  template<typename _CharT, bool _Intl>
+    class moneypunct : public locale::facet, public money_base
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+    private:
+      __cache_type* _M_data;
+    public:
+      static const bool intl = _Intl;
+      static locale::id id;
+      explicit
+      moneypunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(); }
+      explicit
+      moneypunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_moneypunct(); }
+      explicit
+      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(__cloc, __s); }
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+      string
+      grouping() const
+      { return this->do_grouping(); }
+      string_type
+      curr_symbol() const
+      { return this->do_curr_symbol(); }
+      string_type
+      positive_sign() const
+      { return this->do_positive_sign(); }
+      string_type
+      negative_sign() const
+      { return this->do_negative_sign(); }
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+    protected:
+      virtual
+      ~moneypunct();
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+      virtual string_type
+      do_curr_symbol() const
+      { return _M_data->_M_curr_symbol; }
+      virtual string_type
+      do_positive_sign() const
+      { return _M_data->_M_positive_sign; }
+      virtual string_type
+      do_negative_sign() const
+      { return _M_data->_M_negative_sign; }
+      virtual int
+      do_frac_digits() const
+      { return _M_data->_M_frac_digits; }
+      virtual pattern
+      do_pos_format() const
+      { return _M_data->_M_pos_format; }
+      virtual pattern
+      do_neg_format() const
+      { return _M_data->_M_neg_format; }
+       void
+       _M_initialize_moneypunct(__c_locale __cloc = 0,
+    const char* __name = 0);
+    };
+  template<typename _CharT, bool _Intl>
+    locale::id moneypunct<_CharT, _Intl>::id;
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct<_CharT, _Intl>::intl;
+  template<>
+    moneypunct<char, true>::~moneypunct();
+  template<>
+    moneypunct<char, false>::~moneypunct();
+  template<>
+    void
+    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
+  template<>
+    void
+    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
+  template<>
+    moneypunct<wchar_t, true>::~moneypunct();
+  template<>
+    moneypunct<wchar_t, false>::~moneypunct();
+  template<>
+    void
+    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
+       const char*);
+  template<>
+    void
+    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
+        const char*);
+  template<typename _CharT, bool _Intl>
+    class moneypunct_byname : public moneypunct<_CharT, _Intl>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      static const bool intl = _Intl;
+      explicit
+      moneypunct_byname(const char* __s, size_t __refs = 0)
+      : moneypunct<_CharT, _Intl>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_moneypunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+    protected:
+      virtual
+      ~moneypunct_byname() { }
+    };
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct_byname<_CharT, _Intl>::intl;
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter>
+    class money_get : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      typedef basic_string<_CharT> string_type;
+      static locale::id id;
+      explicit
+      money_get(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, long double& __units) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, string_type& __digits) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
+    protected:
+      virtual
+      ~money_get() { }
+      virtual iter_type
+      __do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+        ios_base::iostate& __err, double& __units) const;
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, string_type& __digits) const;
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, long double& __units) const;
+      template<bool _Intl>
+        iter_type
+        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, string& __digits) const;
+    };
+  template<typename _CharT, typename _InIter>
+    locale::id money_get<_CharT, _InIter>::id;
+  template<typename _CharT, typename _OutIter>
+    class money_put : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      typedef basic_string<_CharT> string_type;
+      static locale::id id;
+      explicit
+      money_put(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, long double __units) const
+      { return this->do_put(__s, __intl, __io, __fill, __units); }
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, const string_type& __digits) const
+      { return this->do_put(__s, __intl, __io, __fill, __digits); }
+    protected:
+      virtual
+      ~money_put() { }
+      virtual iter_type
+      __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+        double __units) const;
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      const string_type& __digits) const;
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      long double __units) const;
+      template<bool _Intl>
+        iter_type
+        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+    const string_type& __digits) const;
+    };
+  template<typename _CharT, typename _OutIter>
+    locale::id money_put<_CharT, _OutIter>::id;
+}
+  struct messages_base
+  {
+    typedef int catalog;
+  };
+  template<typename _CharT>
+    class messages : public locale::facet, public messages_base
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+    protected:
+      __c_locale _M_c_locale_messages;
+      const char* _M_name_messages;
+    public:
+      static locale::id id;
+      explicit
+      messages(size_t __refs = 0);
+      explicit
+      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
+      catalog
+      open(const basic_string<char>& __s, const locale& __loc) const
+      { return this->do_open(__s, __loc); }
+      catalog
+      open(const basic_string<char>&, const locale&, const char*) const;
+      string_type
+      get(catalog __c, int __set, int __msgid, const string_type& __s) const
+      { return this->do_get(__c, __set, __msgid, __s); }
+      void
+      close(catalog __c) const
+      { return this->do_close(__c); }
+    protected:
+      virtual
+      ~messages();
+      virtual catalog
+      do_open(const basic_string<char>&, const locale&) const;
+      virtual string_type
+      do_get(catalog, int, int, const string_type& __dfault) const;
+      virtual void
+      do_close(catalog) const;
+      char*
+      _M_convert_to_char(const string_type& __msg) const
+      {
+ return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
+      }
+      string_type
+      _M_convert_from_char(char*) const
+      {
+ return string_type();
+      }
+     };
+  template<typename _CharT>
+    locale::id messages<_CharT>::id;
+  template<>
+    string
+    messages<char>::do_get(catalog, int, int, const string&) const;
+  template<>
+    wstring
+    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
+   template<typename _CharT>
+    class messages_byname : public messages<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      explicit
+      messages_byname(const char* __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~messages_byname()
+      { }
+    };
+}
+extern "C" {
+extern char *gettext (__const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (1)));
+extern char *dgettext (__const char *__domainname, __const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dgettext (__const char *__domainname, __const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *dcgettext (__const char *__domainname,
+   __const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dcgettext (__const char *__domainname,
+     __const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
+         unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
+extern char *dngettext (__const char *__domainname, __const char *__msgid1,
+   __const char *__msgid2, unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
+    __const char *__msgid2, unsigned long int __n,
+    int __category)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+extern char *textdomain (__const char *__domainname) throw ();
+extern char *bindtextdomain (__const char *__domainname,
+        __const char *__dirname) throw ();
+extern char *bind_textdomain_codeset (__const char *__domainname,
+          __const char *__codeset) throw ();
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT>
+     messages<_CharT>::messages(size_t __refs)
+     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
+       _M_name_messages(_S_get_c_name())
+     { }
+  template<typename _CharT>
+     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
+    size_t __refs)
+     : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
+     {
+       if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+  {
+    const size_t __len = __builtin_strlen(__s) + 1;
+    char* __tmp = new char[__len];
+    __builtin_memcpy(__tmp, __s, __len);
+    _M_name_messages = __tmp;
+  }
+       else
+  _M_name_messages = _S_get_c_name();
+       _M_c_locale_messages = _S_clone_c_locale(__cloc);
+     }
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
+      const char* __dir) const
+    {
+      bindtextdomain(__s.c_str(), __dir);
+      return this->do_open(__s, __loc);
+    }
+  template<typename _CharT>
+    messages<_CharT>::~messages()
+    {
+      if (_M_name_messages != _S_get_c_name())
+ delete [] _M_name_messages;
+      _S_destroy_c_locale(_M_c_locale_messages);
+    }
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::do_open(const basic_string<char>& __s,
+         const locale&) const
+    {
+      textdomain(__s.c_str());
+      return 0;
+    }
+  template<typename _CharT>
+    void
+    messages<_CharT>::do_close(catalog) const
+    { }
+   template<typename _CharT>
+     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
+     : messages<_CharT>(__refs)
+     {
+       if (this->_M_name_messages != locale::facet::_S_get_c_name())
+  {
+    delete [] this->_M_name_messages;
+    if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
+      {
+        const size_t __len = __builtin_strlen(__s) + 1;
+        char* __tmp = new char[__len];
+        __builtin_memcpy(__tmp, __s, __len);
+        this->_M_name_messages = __tmp;
+      }
+    else
+      this->_M_name_messages = locale::facet::_S_get_c_name();
+  }
+       if (__builtin_strcmp(__s, "C") != 0
+    && __builtin_strcmp(__s, "POSIX") != 0)
+  {
+    this->_S_destroy_c_locale(this->_M_c_locale_messages);
+    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
+  }
+     }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  class codecvt_base
+  {
+  public:
+    enum result
+    {
+      ok,
+      partial,
+      error,
+      noconv
+    };
+  };
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class __codecvt_abstract_base
+    : public locale::facet, public codecvt_base
+    {
+    public:
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+      result
+      out(state_type& __state, const intern_type* __from,
+   const intern_type* __from_end, const intern_type*& __from_next,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const
+      {
+ return this->do_out(__state, __from, __from_end, __from_next,
+       __to, __to_end, __to_next);
+      }
+      result
+      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
+       extern_type*& __to_next) const
+      { return this->do_unshift(__state, __to,__to_end,__to_next); }
+      result
+      in(state_type& __state, const extern_type* __from,
+  const extern_type* __from_end, const extern_type*& __from_next,
+  intern_type* __to, intern_type* __to_end,
+  intern_type*& __to_next) const
+      {
+ return this->do_in(__state, __from, __from_end, __from_next,
+      __to, __to_end, __to_next);
+      }
+      int
+      encoding() const throw()
+      { return this->do_encoding(); }
+      bool
+      always_noconv() const throw()
+      { return this->do_always_noconv(); }
+      int
+      length(state_type& __state, const extern_type* __from,
+      const extern_type* __end, size_t __max) const
+      { return this->do_length(__state, __from, __end, __max); }
+      int
+      max_length() const throw()
+      { return this->do_max_length(); }
+    protected:
+      explicit
+      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
+      virtual
+      ~__codecvt_abstract_base() { }
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const = 0;
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const = 0;
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const = 0;
+      virtual int
+      do_encoding() const throw() = 0;
+      virtual bool
+      do_always_noconv() const throw() = 0;
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const = 0;
+      virtual int
+      do_max_length() const throw() = 0;
+    };
+   template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt
+    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
+    {
+    public:
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+    protected:
+      __c_locale _M_c_locale_codecvt;
+    public:
+      static locale::id id;
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+    protected:
+      virtual
+      ~codecvt() { }
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+      virtual int
+      do_encoding() const throw();
+      virtual bool
+      do_always_noconv() const throw();
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+      virtual int
+      do_max_length() const throw();
+    };
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+  template<>
+    class codecvt<char, char, mbstate_t>
+    : public __codecvt_abstract_base<char, char, mbstate_t>
+    {
+    public:
+      typedef char intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+    protected:
+      __c_locale _M_c_locale_codecvt;
+    public:
+      static locale::id id;
+      explicit
+      codecvt(size_t __refs = 0);
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+    protected:
+      virtual
+      ~codecvt();
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+      virtual int
+      do_encoding() const throw();
+      virtual bool
+      do_always_noconv() const throw();
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+      virtual int
+      do_max_length() const throw();
+  };
+  template<>
+    class codecvt<wchar_t, char, mbstate_t>
+    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
+    {
+    public:
+      typedef wchar_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+    protected:
+      __c_locale _M_c_locale_codecvt;
+    public:
+      static locale::id id;
+      explicit
+      codecvt(size_t __refs = 0);
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+    protected:
+      virtual
+      ~codecvt();
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+      virtual
+      int do_encoding() const throw();
+      virtual
+      bool do_always_noconv() const throw();
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+      virtual int
+      do_max_length() const throw();
+    };
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
+    {
+    public:
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
+     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
+   }
+      }
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+  extern template class codecvt_byname<char, char, mbstate_t>;
+  extern template
+    const codecvt<char, char, mbstate_t>&
+    use_facet<codecvt<char, char, mbstate_t> >(const locale&);
+  extern template
+    bool
+    has_facet<codecvt<char, char, mbstate_t> >(const locale&);
+  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
+  extern template
+    const codecvt<wchar_t, char, mbstate_t>&
+    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+  extern template
+    bool
+    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _CharT, bool _Intl>
+    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
+    {
+      const __moneypunct_cache<_CharT, _Intl>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
+     try
+       {
+  __tmp = new __moneypunct_cache<_CharT, _Intl>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<
+   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
+      }
+    };
+  template<typename _CharT, bool _Intl>
+    void
+    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+      const moneypunct<_CharT, _Intl>& __mp =
+ use_facet<moneypunct<_CharT, _Intl> >(__loc);
+      _M_decimal_point = __mp.decimal_point();
+      _M_thousands_sep = __mp.thousands_sep();
+      _M_frac_digits = __mp.frac_digits();
+      char* __grouping = 0;
+      _CharT* __curr_symbol = 0;
+      _CharT* __positive_sign = 0;
+      _CharT* __negative_sign = 0;
+      try
+ {
+   _M_grouping_size = __mp.grouping().size();
+   __grouping = new char[_M_grouping_size];
+   __mp.grouping().copy(__grouping, _M_grouping_size);
+   _M_grouping = __grouping;
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(_M_grouping[0]) > 0
+        && (_M_grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+   _M_curr_symbol_size = __mp.curr_symbol().size();
+   __curr_symbol = new _CharT[_M_curr_symbol_size];
+   __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
+   _M_curr_symbol = __curr_symbol;
+   _M_positive_sign_size = __mp.positive_sign().size();
+   __positive_sign = new _CharT[_M_positive_sign_size];
+   __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
+   _M_positive_sign = __positive_sign;
+   _M_negative_sign_size = __mp.negative_sign().size();
+   __negative_sign = new _CharT[_M_negative_sign_size];
+   __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
+   _M_negative_sign = __negative_sign;
+   _M_pos_format = __mp.pos_format();
+   _M_neg_format = __mp.neg_format();
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(money_base::_S_atoms,
+       money_base::_S_atoms + money_base::_S_end, _M_atoms);
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __curr_symbol;
+   delete [] __positive_sign;
+   delete [] __negative_sign;
+   throw;
+ }
+    }
+namespace __gnu_cxx_ldbl128 {
+  template<typename _CharT, typename _InIter>
+    template<bool _Intl>
+      _InIter
+      money_get<_CharT, _InIter>::
+      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, string& __units) const
+      {
+ typedef char_traits<_CharT> __traits_type;
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+ bool __negative = false;
+ size_type __sign_size = 0;
+ const bool __mandatory_sign = (__lc->_M_positive_sign_size
+           && __lc->_M_negative_sign_size);
+ string __grouping_tmp;
+ if (__lc->_M_use_grouping)
+   __grouping_tmp.reserve(32);
+ int __last_pos = 0;
+ int __n = 0;
+ bool __testvalid = true;
+ bool __testdecfound = false;
+ string __res;
+ __res.reserve(32);
+ const char_type* __lit_zero = __lit + money_base::_S_zero;
+ const money_base::pattern __p = __lc->_M_neg_format;
+ for (int __i = 0; __i < 4 && __testvalid; ++__i)
+   {
+     const part __which = static_cast<part>(__p.field[__i]);
+     switch (__which)
+       {
+       case money_base::symbol:
+  if (__io.flags() & ios_base::showbase || __sign_size > 1
+      || __i == 0
+      || (__i == 1 && (__mandatory_sign
+         || (static_cast<part>(__p.field[0])
+      == money_base::sign)
+         || (static_cast<part>(__p.field[2])
+      == money_base::space)))
+      || (__i == 2 && ((static_cast<part>(__p.field[3])
+          == money_base::value)
+         || (__mandatory_sign
+      && (static_cast<part>(__p.field[3])
+          == money_base::sign)))))
+    {
+      const size_type __len = __lc->_M_curr_symbol_size;
+      size_type __j = 0;
+      for (; __beg != __end && __j < __len
+      && *__beg == __lc->_M_curr_symbol[__j];
+    ++__beg, ++__j);
+      if (__j != __len
+   && (__j || __io.flags() & ios_base::showbase))
+        __testvalid = false;
+    }
+  break;
+       case money_base::sign:
+  if (__lc->_M_positive_sign_size && __beg != __end
+      && *__beg == __lc->_M_positive_sign[0])
+    {
+      __sign_size = __lc->_M_positive_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_negative_sign_size && __beg != __end
+    && *__beg == __lc->_M_negative_sign[0])
+    {
+      __negative = true;
+      __sign_size = __lc->_M_negative_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_positive_sign_size
+    && !__lc->_M_negative_sign_size)
+    __negative = true;
+  else if (__mandatory_sign)
+    __testvalid = false;
+  break;
+       case money_base::value:
+  for (; __beg != __end; ++__beg)
+    {
+      const char_type __c = *__beg;
+      const char_type* __q = __traits_type::find(__lit_zero,
+              10, __c);
+      if (__q != 0)
+        {
+   __res += money_base::_S_atoms[__q - __lit];
+   ++__n;
+        }
+      else if (__c == __lc->_M_decimal_point
+        && !__testdecfound)
+        {
+   if (__lc->_M_frac_digits <= 0)
+     break;
+   __last_pos = __n;
+   __n = 0;
+   __testdecfound = true;
+        }
+      else if (__lc->_M_use_grouping
+        && __c == __lc->_M_thousands_sep
+        && !__testdecfound)
+        {
+   if (__n)
+     {
+       __grouping_tmp += static_cast<char>(__n);
+       __n = 0;
+     }
+   else
+     {
+       __testvalid = false;
+       break;
+     }
+        }
+      else
+        break;
+    }
+  if (__res.empty())
+    __testvalid = false;
+  break;
+       case money_base::space:
+  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
+    ++__beg;
+  else
+    __testvalid = false;
+       case money_base::none:
+  if (__i != 3)
+    for (; __beg != __end
+    && __ctype.is(ctype_base::space, *__beg); ++__beg);
+  break;
+       }
+   }
+ if (__sign_size > 1 && __testvalid)
+   {
+     const char_type* __sign = __negative ? __lc->_M_negative_sign
+                                          : __lc->_M_positive_sign;
+     size_type __i = 1;
+     for (; __beg != __end && __i < __sign_size
+     && *__beg == __sign[__i]; ++__beg, ++__i);
+     if (__i != __sign_size)
+       __testvalid = false;
+   }
+ if (__testvalid)
+   {
+     if (__res.size() > 1)
+       {
+  const size_type __first = __res.find_first_not_of('0');
+  const bool __only_zeros = __first == string::npos;
+  if (__first)
+    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
+       }
+     if (__negative && __res[0] != '0')
+       __res.insert(__res.begin(), '-');
+     if (__grouping_tmp.size())
+       {
+  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
+                         : __n);
+  if (!std::__verify_grouping(__lc->_M_grouping,
+         __lc->_M_grouping_size,
+         __grouping_tmp))
+    __err |= ios_base::failbit;
+       }
+     if (__testdecfound && __n != __lc->_M_frac_digits)
+       __testvalid = false;
+   }
+ if (!__testvalid)
+   __err |= ios_base::failbit;
+ else
+   __units.swap(__res);
+ if (__beg == __end)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    __do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+                     : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, long double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, string_type& __digits) const
+    {
+      typedef typename string::size_type size_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      const size_type __len = __str.size();
+      if (__len)
+ {
+   __digits.resize(__len);
+   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
+ }
+      return __beg;
+    }
+  template<typename _CharT, typename _OutIter>
+    template<bool _Intl>
+      _OutIter
+      money_put<_CharT, _OutIter>::
+      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+  const string_type& __digits) const
+      {
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+ const char_type* __beg = __digits.data();
+ money_base::pattern __p;
+ const char_type* __sign;
+ size_type __sign_size;
+ if (!(*__beg == __lit[money_base::_S_minus]))
+   {
+     __p = __lc->_M_pos_format;
+     __sign = __lc->_M_positive_sign;
+     __sign_size = __lc->_M_positive_sign_size;
+   }
+ else
+   {
+     __p = __lc->_M_neg_format;
+     __sign = __lc->_M_negative_sign;
+     __sign_size = __lc->_M_negative_sign_size;
+     if (__digits.size())
+       ++__beg;
+   }
+ size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
+        __beg + __digits.size()) - __beg;
+ if (__len)
+   {
+     string_type __value;
+     __value.reserve(2 * __len);
+     long __paddec = __len - __lc->_M_frac_digits;
+     if (__paddec > 0)
+         {
+  if (__lc->_M_frac_digits < 0)
+    __paddec = __len;
+    if (__lc->_M_grouping_size)
+      {
+      __value.assign(2 * __paddec, char_type());
+       _CharT* __vend =
+        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
+       __lc->_M_grouping,
+       __lc->_M_grouping_size,
+       __beg, __beg + __paddec);
+      __value.erase(__vend - &__value[0]);
+      }
+    else
+    __value.assign(__beg, __paddec);
+       }
+     if (__lc->_M_frac_digits > 0)
+       {
+  __value += __lc->_M_decimal_point;
+  if (__paddec >= 0)
+    __value.append(__beg + __paddec, __lc->_M_frac_digits);
+  else
+    {
+      __value.append(-__paddec, __lit[money_base::_S_zero]);
+      __value.append(__beg, __len);
+    }
+         }
+     const ios_base::fmtflags __f = __io.flags()
+                                    & ios_base::adjustfield;
+     __len = __value.size() + __sign_size;
+     __len += ((__io.flags() & ios_base::showbase)
+        ? __lc->_M_curr_symbol_size : 0);
+     string_type __res;
+     __res.reserve(2 * __len);
+     const size_type __width = static_cast<size_type>(__io.width());
+     const bool __testipad = (__f == ios_base::internal
+         && __len < __width);
+     for (int __i = 0; __i < 4; ++__i)
+       {
+  const part __which = static_cast<part>(__p.field[__i]);
+  switch (__which)
+    {
+    case money_base::symbol:
+      if (__io.flags() & ios_base::showbase)
+        __res.append(__lc->_M_curr_symbol,
+       __lc->_M_curr_symbol_size);
+      break;
+    case money_base::sign:
+      if (__sign_size)
+        __res += __sign[0];
+      break;
+    case money_base::value:
+      __res += __value;
+      break;
+    case money_base::space:
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      else
+        __res += __fill;
+      break;
+    case money_base::none:
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      break;
+    }
+       }
+     if (__sign_size > 1)
+       __res.append(__sign + 1, __sign_size - 1);
+     __len = __res.size();
+     if (__width > __len)
+       {
+  if (__f == ios_base::left)
+    __res.append(__width - __len, __fill);
+  else
+    __res.insert(0, __width - __len, __fill);
+  __len = __width;
+       }
+     __s = std::__write(__s, __res.data(), __len);
+   }
+ __io.width(0);
+ return __s;
+      }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    __do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      double __units) const
+    { return this->do_put(__s, __intl, __io, __fill, (long double) __units); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    long double __units) const
+    {
+      const locale __loc = __io.getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int __cs_size = 64;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+      if (__len >= __cs_size)
+ {
+   __cs_size = __len + 1;
+   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+ }
+      string_type __digits(__len, char_type());
+      __ctype.widen(__cs, __cs + __len, &__digits[0]);
+      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits);
+    }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    const string_type& __digits) const
+    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits); }
+}
+  template<typename _CharT, typename _InIter>
+    time_base::dateorder
+    time_get<_CharT, _InIter>::do_date_order() const
+    { return time_base::no_order; }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm,
+     const _CharT* __format) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const size_t __len = char_traits<_CharT>::length(__format);
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      size_t __i = 0;
+      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
+ {
+   if (__ctype.narrow(__format[__i], 0) == '%')
+     {
+       char __c = __ctype.narrow(__format[++__i], 0);
+       int __mem = 0;
+       if (__c == 'E' || __c == 'O')
+  __c = __ctype.narrow(__format[++__i], 0);
+       switch (__c)
+  {
+    const char* __cs;
+    _CharT __wcs[10];
+  case 'a':
+    const char_type* __days1[7];
+    __tp._M_days_abbreviated(__days1);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
+       7, __io, __tmperr);
+    break;
+  case 'A':
+    const char_type* __days2[7];
+    __tp._M_days(__days2);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
+       7, __io, __tmperr);
+    break;
+  case 'h':
+  case 'b':
+    const char_type* __months1[12];
+    __tp._M_months_abbreviated(__months1);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
+       __months1, 12, __io, __tmperr);
+    break;
+  case 'B':
+    const char_type* __months2[12];
+    __tp._M_months(__months2);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
+       __months2, 12, __io, __tmperr);
+    break;
+  case 'c':
+    const char_type* __dt[2];
+    __tp._M_date_time_formats(__dt);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dt[0]);
+    break;
+  case 'd':
+    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
+      __io, __tmperr);
+    break;
+  case 'e':
+    if (__ctype.is(ctype_base::space, *__beg))
+      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
+        1, __io, __tmperr);
+    else
+      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
+        2, __io, __tmperr);
+    break;
+  case 'D':
+    __cs = "%m/%d/%y";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'H':
+    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
+      __io, __tmperr);
+    break;
+  case 'I':
+    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
+      __io, __tmperr);
+    break;
+  case 'm':
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem - 1;
+    break;
+  case 'M':
+    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
+      __io, __tmperr);
+    break;
+  case 'n':
+    if (__ctype.narrow(*__beg, 0) == '\n')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'R':
+    __cs = "%H:%M";
+    __ctype.widen(__cs, __cs + 6, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'S':
+    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
+      __io, __tmperr);
+    break;
+  case 't':
+    if (__ctype.narrow(*__beg, 0) == '\t')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'T':
+    __cs = "%H:%M:%S";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'x':
+    const char_type* __dates[2];
+    __tp._M_date_formats(__dates);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dates[0]);
+    break;
+  case 'X':
+    const char_type* __times[2];
+    __tp._M_time_formats(__times);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __times[0]);
+    break;
+  case 'y':
+  case 'C':
+  case 'Y':
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
+    break;
+  case 'Z':
+    if (__ctype.is(ctype_base::upper, *__beg))
+      {
+        int __tmp;
+        __beg = _M_extract_name(__beg, __end, __tmp,
+           __timepunct_cache<_CharT>::_S_timezones,
+           14, __io, __tmperr);
+        if (__beg != __end && !__tmperr && __tmp == 0
+     && (*__beg == __ctype.widen('-')
+         || *__beg == __ctype.widen('+')))
+   {
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
+       __io, __tmperr);
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
+       __io, __tmperr);
+   }
+      }
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  default:
+    __tmperr |= ios_base::failbit;
+  }
+     }
+   else
+     {
+       if (__format[__i] == *__beg)
+  ++__beg;
+       else
+  __tmperr |= ios_base::failbit;
+     }
+ }
+      if (__tmperr || __i != __len)
+ __err |= ios_base::failbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+     int __min, int __max, size_t __len,
+     ios_base& __io, ios_base::iostate& __err) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
+      ++__min;
+      size_t __i = 0;
+      int __value = 0;
+      for (; __beg != __end && __i < __len; ++__beg, ++__i)
+ {
+   const char __c = __ctype.narrow(*__beg, '*');
+   if (__c >= '0' && __c <= '9')
+     {
+       __value = __value * 10 + (__c - '0');
+       const int __valuec = __value * __mult;
+       if (__valuec > __max || __valuec + __mult < __min)
+  break;
+       __mult /= 10;
+     }
+   else
+     break;
+ }
+      if (__i == __len)
+ __member = __value;
+      else if (__len == 4 && __i == 2)
+ __member = __value - 100;
+      else
+ __err |= ios_base::failbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+      const _CharT** __names, size_t __indexlen,
+      ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t __pos = 0;
+      bool __testvalid = true;
+      const char_type* __name;
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
+     if (__c == __names[__i1][0]
+  || __c == __ctype.toupper(__names[__i1][0]))
+       __matches[__nmatches++] = __i1;
+ }
+      while (__nmatches > 1)
+ {
+   size_t __minlen = __traits_type::length(__names[__matches[0]]);
+   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
+     __minlen = std::min(__minlen,
+         __traits_type::length(__names[__matches[__i2]]));
+   ++__beg, ++__pos;
+   if (__pos < __minlen && __beg != __end)
+     for (size_t __i3 = 0; __i3 < __nmatches;)
+       {
+  __name = __names[__matches[__i3]];
+  if (!(__name[__pos] == *__beg))
+    __matches[__i3] = __matches[--__nmatches];
+  else
+    ++__i3;
+       }
+   else
+     break;
+ }
+      if (__nmatches == 1)
+ {
+   ++__beg, ++__pos;
+   __name = __names[__matches[0]];
+   const size_t __len = __traits_type::length(__name);
+   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
+     ++__beg, ++__pos;
+   if (__len == __pos)
+     __member = __matches[0];
+   else
+     __testvalid = false;
+ }
+      else
+ __testvalid = false;
+      if (!__testvalid)
+ __err |= ios_base::failbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t* __matches_lengths = 0;
+      size_t __pos = 0;
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
+     if (__c == __names[__i][0]
+  || __c == __ctype.toupper(__names[__i][0]))
+       __matches[__nmatches++] = __i;
+ }
+      if (__nmatches)
+ {
+   ++__beg, ++__pos;
+   __matches_lengths
+     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
+          * __nmatches));
+   for (size_t __i = 0; __i < __nmatches; ++__i)
+     __matches_lengths[__i]
+       = __traits_type::length(__names[__matches[__i]]);
+ }
+      for (; __beg != __end; ++__beg, ++__pos)
+ {
+   size_t __nskipped = 0;
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < __nmatches;)
+     {
+       const char_type* __name = __names[__matches[__i]];
+       if (__pos >= __matches_lengths[__i])
+  ++__nskipped, ++__i;
+       else if (!(__name[__pos] == __c))
+  {
+    --__nmatches;
+    __matches[__i] = __matches[__nmatches];
+    __matches_lengths[__i] = __matches_lengths[__nmatches];
+  }
+       else
+  ++__i;
+     }
+   if (__nskipped == __nmatches)
+     break;
+ }
+      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
+   || (__nmatches == 2 && (__matches_lengths[0] == __pos
+      || __matches_lengths[1] == __pos)))
+ __member = (__matches[0] >= __indexlen
+      ? __matches[0] - __indexlen : __matches[0]);
+      else
+ __err |= ios_base::failbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __times[2];
+      __tp._M_time_formats(__times);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __times[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __dates[2];
+      __tp._M_date_formats(__dates);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __dates[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type* __days[14];
+      __tp._M_days_abbreviated(__days);
+      __tp._M_days(__days + 7);
+      int __tmpwday;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_wday = __tmpwday;
+      else
+ __err |= ios_base::failbit;
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+     }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_monthname(iter_type __beg, iter_type __end,
+                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type* __months[24];
+      __tp._M_months_abbreviated(__months);
+      __tp._M_months(__months + 12);
+      int __tmpmon;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_mon = __tmpmon;
+      else
+ __err |= ios_base::failbit;
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int __tmpyear;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
+        __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
+      else
+ __err |= ios_base::failbit;
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+ const _CharT* __beg, const _CharT* __end) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      for (; __beg != __end; ++__beg)
+ if (__ctype.narrow(*__beg, 0) != '%')
+   {
+     *__s = *__beg;
+     ++__s;
+   }
+ else if (++__beg != __end)
+   {
+     char __format;
+     char __mod = 0;
+     const char __c = __ctype.narrow(*__beg, 0);
+     if (__c != 'E' && __c != 'O')
+       __format = __c;
+     else if (++__beg != __end)
+       {
+  __mod = __c;
+  __format = __ctype.narrow(*__beg, 0);
+       }
+     else
+       break;
+     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
+   }
+ else
+   break;
+      return __s;
+    }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
+    char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const size_t __maxlen = 128;
+      char_type __res[__maxlen];
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+ {
+   __fmt[1] = __format;
+   __fmt[2] = char_type();
+ }
+      else
+ {
+   __fmt[1] = __mod;
+   __fmt[2] = __format;
+   __fmt[3] = char_type();
+ }
+      __tp._M_put(__res, __maxlen, __fmt, __tm);
+      return std::__write(__s, __res, char_traits<char_type>::length(__res));
+    }
+  extern template class moneypunct<char, false>;
+  extern template class moneypunct<char, true>;
+  extern template class moneypunct_byname<char, false>;
+  extern template class moneypunct_byname<char, true>;
+  extern template class __gnu_cxx_ldbl128:: money_get<char>;
+  extern template class __gnu_cxx_ldbl128:: money_put<char>;
+  extern template class __timepunct<char>;
+  extern template class time_put<char>;
+  extern template class time_put_byname<char>;
+  extern template class time_get<char>;
+  extern template class time_get_byname<char>;
+  extern template class messages<char>;
+  extern template class messages_byname<char>;
+  extern template
+    const moneypunct<char, true>&
+    use_facet<moneypunct<char, true> >(const locale&);
+  extern template
+    const moneypunct<char, false>&
+    use_facet<moneypunct<char, false> >(const locale&);
+  extern template
+    const money_put<char>&
+    use_facet<money_put<char> >(const locale&);
+  extern template
+    const money_get<char>&
+    use_facet<money_get<char> >(const locale&);
+  extern template
+    const __timepunct<char>&
+    use_facet<__timepunct<char> >(const locale&);
+  extern template
+    const time_put<char>&
+    use_facet<time_put<char> >(const locale&);
+  extern template
+    const time_get<char>&
+    use_facet<time_get<char> >(const locale&);
+  extern template
+    const messages<char>&
+    use_facet<messages<char> >(const locale&);
+  extern template
+    bool
+    has_facet<moneypunct<char> >(const locale&);
+  extern template
+    bool
+    has_facet<money_put<char> >(const locale&);
+  extern template
+    bool
+    has_facet<money_get<char> >(const locale&);
+  extern template
+    bool
+    has_facet<__timepunct<char> >(const locale&);
+  extern template
+    bool
+    has_facet<time_put<char> >(const locale&);
+  extern template
+    bool
+    has_facet<time_get<char> >(const locale&);
+  extern template
+    bool
+    has_facet<messages<char> >(const locale&);
+  extern template class moneypunct<wchar_t, false>;
+  extern template class moneypunct<wchar_t, true>;
+  extern template class moneypunct_byname<wchar_t, false>;
+  extern template class moneypunct_byname<wchar_t, true>;
+  extern template class __gnu_cxx_ldbl128:: money_get<wchar_t>;
+  extern template class __gnu_cxx_ldbl128:: money_put<wchar_t>;
+  extern template class __timepunct<wchar_t>;
+  extern template class time_put<wchar_t>;
+  extern template class time_put_byname<wchar_t>;
+  extern template class time_get<wchar_t>;
+  extern template class time_get_byname<wchar_t>;
+  extern template class messages<wchar_t>;
+  extern template class messages_byname<wchar_t>;
+  extern template
+    const moneypunct<wchar_t, true>&
+    use_facet<moneypunct<wchar_t, true> >(const locale&);
+  extern template
+    const moneypunct<wchar_t, false>&
+    use_facet<moneypunct<wchar_t, false> >(const locale&);
+  extern template
+    const money_put<wchar_t>&
+    use_facet<money_put<wchar_t> >(const locale&);
+  extern template
+    const money_get<wchar_t>&
+    use_facet<money_get<wchar_t> >(const locale&);
+  extern template
+    const __timepunct<wchar_t>&
+    use_facet<__timepunct<wchar_t> >(const locale&);
+  extern template
+    const time_put<wchar_t>&
+    use_facet<time_put<wchar_t> >(const locale&);
+  extern template
+    const time_get<wchar_t>&
+    use_facet<time_get<wchar_t> >(const locale&);
+  extern template
+    const messages<wchar_t>&
+    use_facet<messages<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<moneypunct<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<money_put<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<money_get<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<__timepunct<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<time_put<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<time_get<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<messages<wchar_t> >(const locale&);
+}
+namespace std {
+}
+namespace boost { namespace iostreams {
+typedef boost::intmax_t stream_offset;
+inline std::streamoff stream_offset_to_streamoff(stream_offset off)
+{ return static_cast<stream_offset>(off); }
+inline std::streampos offset_to_position(stream_offset off) { return off; }
+template<typename PosType>
+inline stream_offset position_to_offset(PosType pos)
+{ return std::streamoff(pos); }
+inline stream_offset position_to_offset(std::streampos pos) { return pos; }
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct seek_device_impl;
+template<typename T>
+struct seek_filter_impl;
+}
+template<typename T>
+inline std::streampos
+seek( T& t, stream_offset off, std::ios::seekdir way,
+      std::ios::openmode which = std::ios::in | std::ios::out )
+{
+    using namespace detail;
+    return seek_device_impl<T>::seek(detail::unwrap(t), off, way, which);
+}
+template<typename T, typename Device>
+inline std::streampos
+seek( T& t, Device& dev, stream_offset off, std::ios::seekdir way,
+      std::ios::openmode which = std::ios::in | std::ios::out )
+{
+    using namespace detail;
+    return seek_filter_impl<T>::seek(detail::unwrap(t), dev, off, way, which);
+}
+namespace detail {
+template<typename T>
+struct seek_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          seek_device_impl<
+              typename
+              dispatch<
+                  T, iostream_tag, istream_tag, ostream_tag,
+                  streambuf_tag, two_head, any_tag
+              >::type
+          >
+      >::type
+    { };
+struct seek_impl_basic_ios {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode which )
+    {
+        if ( way == std::ios::beg &&
+             ( off < integer_traits<std::streamoff>::const_min ||
+               off > integer_traits<std::streamoff>::const_max ) )
+        {
+            return t.rdbuf()->pubseekpos(offset_to_position(off));
+        } else {
+            return t.rdbuf()->pubseekoff(off, way, which);
+        }
+    }
+};
+template<>
+struct seek_device_impl<iostream_tag> : seek_impl_basic_ios { };
+template<>
+struct seek_device_impl<istream_tag> : seek_impl_basic_ios { };
+template<>
+struct seek_device_impl<ostream_tag> : seek_impl_basic_ios { };
+template<>
+struct seek_device_impl<streambuf_tag> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode which )
+    {
+        if ( way == std::ios::beg &&
+             ( off < integer_traits<std::streamoff>::const_min ||
+               off > integer_traits<std::streamoff>::const_max ) )
+        {
+            return t.pubseekpos(offset_to_position(off));
+        } else {
+            return t.pubseekoff(off, way, which);
+        }
+    }
+};
+template<>
+struct seek_device_impl<two_head> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode which )
+    { return t.seek(off, way, which); }
+};
+template<>
+struct seek_device_impl<any_tag> {
+    template<typename T>
+    static std::streampos seek( T& t, stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode )
+    { return t.seek(off, way); }
+};
+template<typename T>
+struct seek_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          seek_filter_impl<
+              typename
+              dispatch<T, two_head, any_tag>::type
+          >
+      >::type
+    { };
+template<>
+struct seek_filter_impl<two_head> {
+    template<typename T, typename Device>
+    static std::streampos seek( T& t, Device& d,
+                                stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode which )
+    { return t.seek(d, off, way, which); }
+};
+template<>
+struct seek_filter_impl<any_tag> {
+    template<typename T, typename Device>
+    static std::streampos seek( T& t, Device& d,
+                                stream_offset off,
+                                std::ios::seekdir way,
+                                std::ios::openmode )
+    { return t.seek(d, off, way); }
+};
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct write_device_impl;
+template<typename T>
+struct write_filter_impl;
+}
+template<typename T>
+bool put(T& t, typename char_type_of<T>::type c)
+{ return detail::write_device_impl<T>::put(detail::unwrap(t), c); }
+template<typename T>
+inline std::streamsize write
+    (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+{ return detail::write_device_impl<T>::write(detail::unwrap(t), s, n); }
+template<typename T, typename Sink>
+inline std::streamsize
+write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
+       std::streamsize n )
+{ return detail::write_filter_impl<T>::write(detail::unwrap(t), snk, s, n); }
+namespace detail {
+template<typename T>
+struct write_device_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          write_device_impl<
+              typename
+              dispatch<
+                  T, ostream_tag, streambuf_tag, output
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct write_device_impl<ostream_tag> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef std::char_traits< char_type > traits_type;
+        return !traits_type::eq_int_type( t.rdbuf()->sputc(c),
+                                          traits_type::eof() );
+    }
+    template<typename T>
+    static std::streamsize write
+        (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.rdbuf()->sputn(s, n); }
+};
+template<>
+struct write_device_impl<streambuf_tag> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    {
+        typedef typename char_type_of<T>::type char_type;
+        typedef std::char_traits< char_type > traits_type;
+        return !traits_type::eq_int_type(t.sputc(c), traits_type::eof());
+    }
+    template<typename T>
+    static std::streamsize write
+        (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.sputn(s, n); }
+};
+template<>
+struct write_device_impl<output> {
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    { return t.write(&c, 1) == 1; }
+    template<typename T>
+    static std::streamsize
+    write(T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+    { return t.write(s, n); }
+};
+template<typename T>
+struct write_filter_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          write_filter_impl<
+              typename
+              dispatch<
+                  T, multichar_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct write_filter_impl<multichar_tag> {
+    template<typename T, typename Sink>
+    static std::streamsize
+    write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
+           std::streamsize n )
+    { return t.write(snk, s, n); }
+};
+template<>
+struct write_filter_impl<any_tag> {
+    template<typename T, typename Sink>
+    static std::streamsize
+    write( T& t, Sink& snk, const typename char_type_of<T>::type* s,
+           std::streamsize n )
+    {
+        for (std::streamsize off = 0; off < n; ++off)
+            if (!t.put(snk, s[off]))
+                return off;
+        return n;
+    }
+};
+}
+} }
+namespace boost { namespace iostreams {
+template<typename Device>
+class non_blocking_adapter {
+public:
+    typedef typename char_type_of<Device>::type char_type;
+    struct category
+        : mode_of<Device>::type, device_tag
+        { };
+    explicit non_blocking_adapter(Device& dev) : device_(dev) { }
+    std::streamsize read(char_type* s, std::streamsize n)
+    {
+        std::streamsize result = 0;
+        while (result < n) {
+            std::streamsize amt = iostreams::read(device_, s, n);
+            if (amt == -1)
+                break;
+            result += amt;
+        }
+        return result != 0 ? result : -1;
+    }
+    std::streamsize write(const char_type* s, std::streamsize n)
+    {
+        std::streamsize result = 0;
+        while (result < n) {
+            std::streamsize amt =
+                iostreams::write(device_, s + result, n - result);
+            result += amt;
+        }
+        return result;
+    }
+    std::streampos seek( stream_offset off, std::ios::seekdir way,
+                         std::ios::openmode which =
+                             std::ios::in | std::ios::out )
+    { return iostreams::seek(device_, off, way, which); }
+public:
+    non_blocking_adapter& operator=(const non_blocking_adapter&);
+    Device& device_;
+};
+} }
+namespace boost { namespace iostreams {
+template<typename T>
+void close(T& t);
+template<typename T>
+void close(T& t, std::ios::openmode which);
+template<typename T, typename Sink>
+void close(T& t, Sink& snk, std::ios::openmode which);
+namespace detail {
+template<typename T>
+void close_all(T& t)
+{
+    try {
+        boost::iostreams::close(t, std::ios::in);
+    } catch (...) {
+        try {
+            boost::iostreams::close(t, std::ios::out);
+        } catch (...) { }
+        throw;
+    }
+    boost::iostreams::close(t, std::ios::out);
+}
+template<typename T, typename Sink>
+void close_all(T& t, Sink& snk)
+{
+    try {
+        boost::iostreams::close(t, snk, std::ios::in);
+    } catch (...) {
+        try {
+            boost::iostreams::close(t, snk, std::ios::out);
+        } catch (...) { }
+        throw;
+    }
+    boost::iostreams::close(t, snk, std::ios::out);
+}
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct close_impl;
+}
+template<typename T>
+void close(T& t) { detail::close_all(t); }
+template<typename T>
+void close(T& t, std::ios::openmode which)
+{
+    if (which == (std::ios::in | std::ios::out)) {
+        detail::close_all(t);
+        return;
+    }
+    detail::close_impl<T>::close(detail::unwrap(t), which);
+}
+template<typename T, typename Sink>
+void close(T& t, Sink& snk, std::ios::openmode which)
+{
+    if (which == (std::ios::in | std::ios::out)) {
+        detail::close_all(t, snk);
+        return;
+    }
+    detail::close_impl<T>::close(detail::unwrap(t), snk, which);
+}
+namespace detail {
+struct close_boost_stream { };
+struct close_filtering_stream { };
+template<typename T>
+struct close_tag {
+    typedef typename category_of<T>::type category;
+    typedef typename detail::unwrapped_type<T>::type unwrapped;
+    typedef typename
+            iostreams::select<
+                mpl::not_< is_convertible<category, closable_tag> >,
+                any_tag,
+                mpl::or_<
+                    is_boost_stream<unwrapped>,
+                    is_boost_stream_buffer<unwrapped>
+                >,
+                close_boost_stream,
+                mpl::or_<
+                    is_filtering_stream<unwrapped>,
+                    is_filtering_streambuf<unwrapped>
+                >,
+                close_filtering_stream,
+                mpl::or_<
+                    is_convertible<category, two_sequence>,
+                    is_convertible<category, dual_use>
+                >,
+                two_sequence,
+                else_,
+                closable_tag
+            >::type type;
+};
+template<typename T>
+struct close_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          close_impl<typename close_tag<T>::type>
+      >::type
+    { };
+template<>
+struct close_impl<any_tag> {
+    template<typename T>
+    static void close(T& t, std::ios::openmode which)
+    {
+        if (which == std::ios::out)
+            iostreams::flush(t);
+    }
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, std::ios::openmode which)
+    {
+        if (which == std::ios::out) {
+            non_blocking_adapter<Sink> nb(snk);
+            iostreams::flush(t, nb);
+        }
+    }
+};
+template<>
+struct close_impl<close_boost_stream> {
+    template<typename T>
+    static void close(T& t)
+    {
+        t.close();
+    }
+    template<typename T>
+    static void close(T& t, std::ios::openmode which)
+    {
+        if (which == std::ios::out)
+            t.close();
+    }
+};
+template<>
+struct close_impl<close_filtering_stream> {
+    template<typename T>
+    static void close(T& t, std::ios::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in = is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == std::ios::in) && t.is_complete())
+            t.pop();
+    }
+};
+template<>
+struct close_impl<closable_tag> {
+    template<typename T>
+    static void close(T& t, std::ios::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in = is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == std::ios::in))
+            t.close();
+    }
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, std::ios::openmode which)
+    {
+        typedef typename category_of<T>::type category;
+        const bool in = is_convertible<category, input>::value &&
+                        !is_convertible<category, output>::value;
+        if (in == (which == std::ios::in)) {
+            non_blocking_adapter<Sink> nb(snk);
+            t.close(nb);
+        }
+    }
+};
+template<>
+struct close_impl<two_sequence> {
+    template<typename T>
+    static void close(T& t, std::ios::openmode which) { t.close(which); }
+    template<typename T, typename Sink>
+    static void close(T& t, Sink& snk, std::ios::openmode which)
+    {
+        non_blocking_adapter<Sink> nb(snk);
+        t.close(nb, which);
+    }
+};
+}
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T>
+class device_close_operation {
+public:
+    typedef void result_type;
+    device_close_operation(T& t, std::ios::openmode which)
+        : t_(t), which_(which)
+        { }
+    void operator()() const { boost::iostreams::close(t_, which_); }
+private:
+    device_close_operation& operator=(const device_close_operation&);
+    T& t_;
+    std::ios::openmode which_;
+};
+template<typename T, typename Sink>
+class filter_close_operation {
+public:
+    typedef void result_type;
+    filter_close_operation(T& t, Sink& snk, std::ios::openmode which)
+        : t_(t), snk_(snk), which_(which)
+        { }
+    void operator()() const { boost::iostreams::close(t_, snk_, which_); }
+private:
+    filter_close_operation& operator=(const filter_close_operation&);
+    T& t_;
+    Sink& snk_;
+    std::ios::openmode which_;
+};
+template<typename T>
+device_close_operation<T>
+call_close(T& t, std::ios::openmode which)
+{ return device_close_operation<T>(t, which); }
+template<typename T, typename Sink>
+filter_close_operation<T, Sink>
+call_close(T& t, Sink& snk, std::ios::openmode which)
+{ return filter_close_operation<T, Sink>(t, snk, which); }
+template<typename T>
+class device_close_all_operation {
+public:
+    typedef void result_type;
+    device_close_all_operation(T& t) : t_(t) { }
+    void operator()() const { detail::close_all(t_); }
+private:
+    device_close_all_operation& operator=(const device_close_all_operation&);
+    T& t_;
+};
+template<typename T, typename Sink>
+class filter_close_all_operation {
+public:
+    typedef void result_type;
+    filter_close_all_operation(T& t, Sink& snk) : t_(t), snk_(snk) { }
+    void operator()() const { detail::close_all(t_, snk_); }
+private:
+    filter_close_all_operation& operator=(const filter_close_all_operation&);
+    T& t_;
+    Sink& snk_;
+};
+template<typename T>
+device_close_all_operation<T> call_close_all(T& t)
+{ return device_close_all_operation<T>(t); }
+template<typename T, typename Sink>
+filter_close_all_operation<T, Sink>
+call_close_all(T& t, Sink& snk)
+{ return filter_close_all_operation<T, Sink>(t, snk); }
+template<typename T>
+class member_close_operation {
+public:
+    typedef void result_type;
+    member_close_operation(T& t, std::ios::openmode which)
+        : t_(t), which_(which)
+        { }
+    void operator()() const { t_.close(which_); }
+private:
+    member_close_operation& operator=(const member_close_operation&);
+    T& t_;
+    std::ios::openmode which_;
+};
+template<typename T>
+member_close_operation<T> call_member_close(T& t, std::ios::openmode which)
+{ return member_close_operation<T>(t, which); }
+template<typename T>
+class reset_operation {
+public:
+    reset_operation(T& t) : t_(t) { }
+    void operator()() const { t_.reset(); }
+private:
+    reset_operation& operator=(const reset_operation&);
+    T& t_;
+};
+template<typename T>
+reset_operation<T> call_reset(T& t) { return reset_operation<T>(t); }
+template<typename T>
+class clear_flags_operation {
+public:
+    typedef void result_type;
+    clear_flags_operation(T& t) : t_(t) { }
+    void operator()() const { t_ = 0; }
+private:
+    clear_flags_operation& operator=(const clear_flags_operation&);
+    T& t_;
+};
+template<typename T>
+clear_flags_operation<T> clear_flags(T& t)
+{ return clear_flags_operation<T>(t); }
+template<typename Buffer, typename Device>
+class flush_buffer_operation {
+public:
+    typedef void result_type;
+    flush_buffer_operation(Buffer& buf, Device& dev, bool flush)
+        : buf_(buf), dev_(dev), flush_(flush)
+        { }
+    void operator()() const
+    {
+        if (flush_)
+            buf_.flush(dev_);
+    }
+private:
+    flush_buffer_operation& operator=(const flush_buffer_operation&);
+    Buffer& buf_;
+    Device& dev_;
+    bool flush_;
+};
+template<typename Buffer, typename Device>
+flush_buffer_operation<Buffer, Device>
+flush_buffer(Buffer& buf, Device& dev, bool flush)
+{ return flush_buffer_operation<Buffer, Device>(buf, dev, flush); }
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<class T>
+class aligned_storage
+{
+    union dummy_u
+    {
+        char data[ sizeof(T) ];
+        typename type_with_alignment<
+          ::boost::alignment_of<T>::value >::type aligner_;
+    } dummy_ ;
+  public:
+    void const* address() const { return &dummy_.data[0]; }
+    void * address() { return &dummy_.data[0]; }
+};
+template<typename T>
+class optional {
+public:
+    typedef T element_type;
+    optional() : initialized_(false) { }
+    optional(const T& t) : initialized_(false) { reset(t); }
+    ~optional() { reset(); }
+    T& operator*()
+    {
+        (static_cast<void> (0));
+        return *static_cast<T*>(address());
+    }
+    const T& operator*() const
+    {
+        (static_cast<void> (0));
+        return *static_cast<const T*>(address());
+    }
+    T* operator->()
+    {
+        (static_cast<void> (0));
+        return static_cast<T*>(address());
+    }
+    const T* operator->() const
+    {
+        (static_cast<void> (0));
+        return static_cast<const T*>(address());
+    }
+    T* get()
+    {
+        (static_cast<void> (0));
+        return static_cast<T*>(address());
+    }
+    const T* get() const
+    {
+        (static_cast<void> (0));
+        return static_cast<const T*>(address());
+    }
+    void reset()
+    {
+        if (initialized_) {
+            static_cast<T*>(address())->T::~T();
+            initialized_ = false;
+        }
+    }
+    void reset(const T& t)
+    {
+        reset();
+        new (address()) T(t);
+        initialized_ = true;
+    }
+private:
+    optional(const optional&);
+    optional& operator=(const optional&);
+    void* address() { return &storage_; }
+    const void* address() const { return &storage_; }
+    aligned_storage<T> storage_;
+    bool initialized_;
+};
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Self, typename Ch, typename Tr, typename Alloc, typename Mode>
+class chain_base;
+template<typename Chain, typename Access, typename Mode> class chainbuf;
+template<typename Ch, typename Tr = std::char_traits< Ch > >
+class linked_streambuf : public std::basic_streambuf< Ch, Tr > {
+protected:
+    linked_streambuf() : flags_(0) { }
+    void set_true_eof(bool eof)
+    {
+        flags_ = (flags_ & ~f_true_eof) | (eof ? f_true_eof : 0);
+    }
+public:
+    bool true_eof() const { return (flags_ & f_true_eof) != 0; }
+protected:
+    template< typename Self, typename ChT, typename TrT,
+              typename Alloc, typename Mode >
+    friend class chain_base;
+    template<typename Chain, typename Mode, typename Access>
+    friend class chainbuf;
+    template<typename U>
+    friend class member_close_operation;
+    void close(std::ios::openmode which)
+    {
+        if ( which == std::ios::in &&
+            (flags_ & f_input_closed) == 0 )
+        {
+            flags_ |= f_input_closed;
+            close_impl(which);
+        }
+        if ( which == std::ios::out &&
+            (flags_ & f_output_closed) == 0 )
+        {
+            flags_ |= f_output_closed;
+            close_impl(which);
+        }
+    }
+    void set_needs_close()
+    {
+        flags_ &= ~(f_input_closed | f_output_closed);
+    }
+    virtual void set_next(linked_streambuf<Ch, Tr>* ) { }
+    virtual void close_impl(std::ios::openmode) = 0;
+    virtual bool auto_close() const = 0;
+    virtual void set_auto_close(bool) = 0;
+    virtual bool strict_sync() = 0;
+    virtual const std::type_info& component_type() const = 0;
+    virtual void* component_impl() = 0;
+    private:
+private:
+    enum flag_type {
+        f_true_eof = 1,
+        f_input_closed = f_true_eof << 1,
+        f_output_closed = f_input_closed << 1
+    };
+    int flags_;
+};
+} } }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct imbue_impl;
+}
+template<typename T, typename Locale>
+void imbue(T& t, const Locale& loc)
+{ detail::imbue_impl<T>::imbue(detail::unwrap(t), loc); }
+namespace detail {
+template<typename T>
+struct imbue_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          imbue_impl<
+              typename
+              dispatch<
+                  T, streambuf_tag, localizable_tag, any_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct imbue_impl<any_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T&, const Locale&) { }
+};
+template<>
+struct imbue_impl<streambuf_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T& t, const Locale& loc) { t.pubimbue(loc); }
+};
+template<>
+struct imbue_impl<localizable_tag> {
+    template<typename T, typename Locale>
+    static void imbue(T& t, const Locale& loc) { t.imbue(loc); }
+};
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct input_sequence_impl;
+}
+template<typename T>
+inline std::pair<
+    typename char_type_of<T>::type*,
+    typename char_type_of<T>::type*
+>
+input_sequence(T& t)
+{ return detail::input_sequence_impl<T>::input_sequence(t); }
+namespace detail {
+template<typename T>
+struct input_sequence_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          input_sequence_impl<direct_tag>
+      >::type
+    { };
+template<>
+struct input_sequence_impl<direct_tag> {
+    template<typename U>
+    static std::pair<
+        typename char_type_of<U>::type*,
+        typename char_type_of<U>::type*
+    >
+    input_sequence(U& u) { return u.input_sequence(); }
+};
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct optimal_buffer_size_impl;
+}
+template<typename T>
+std::streamsize optimal_buffer_size(const T& t)
+{
+    typedef detail::optimal_buffer_size_impl<T> impl;
+    return impl::optimal_buffer_size(detail::unwrap(t));
+}
+namespace detail {
+template<typename T>
+struct optimal_buffer_size_impl
+    : mpl::if_<
+          is_custom<T>,
+          operations<T>,
+          optimal_buffer_size_impl<
+              typename
+              dispatch<
+                  T, optimally_buffered_tag, device_tag, filter_tag
+              >::type
+          >
+      >::type
+    { };
+template<>
+struct optimal_buffer_size_impl<optimally_buffered_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T& t)
+    { return t.optimal_buffer_size(); }
+};
+template<>
+struct optimal_buffer_size_impl<device_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T&)
+    { return default_device_buffer_size; }
+};
+template<>
+struct optimal_buffer_size_impl<filter_tag> {
+    template<typename T>
+    static std::streamsize optimal_buffer_size(const T&)
+    { return default_filter_buffer_size; }
+};
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct output_sequence_impl;
+}
+template<typename T>
+inline std::pair<
+    typename char_type_of<T>::type*,
+    typename char_type_of<T>::type*
+>
+output_sequence(T& t)
+{ return detail::output_sequence_impl<T>::output_sequence(t); }
+namespace detail {
+template<typename T>
+struct output_sequence_impl
+    : mpl::if_<
+          detail::is_custom<T>,
+          operations<T>,
+          output_sequence_impl<direct_tag>
+      >::type
+    { };
+template<>
+struct output_sequence_impl<direct_tag> {
+    template<typename U>
+    static std::pair<
+        typename char_type_of<U>::type*,
+        typename char_type_of<U>::type*
+    >
+    output_sequence(U& u) { return u.output_sequence(); }
+};
+}
+} }
+namespace boost { namespace iostreams {
+namespace detail {
+template< typename T,
+          typename Tr =
+              std::char_traits< typename char_type_of<T>::type >
+                >
+class direct_streambuf
+    : public linked_streambuf<typename char_type_of<T>::type, Tr>
+{
+public:
+    typedef typename char_type_of<T>::type char_type;
+    typedef Tr traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::off_type off_type; typedef typename traits_type::pos_type pos_type;
+private:
+    typedef linked_streambuf<char_type, traits_type> base_type;
+    typedef typename category_of<T>::type category;
+    typedef std::basic_streambuf< char_type, traits_type >
+                                                          streambuf_type;
+public:
+    void open(const T& t, std::streamsize buffer_size,
+              std::streamsize pback_size);
+    bool is_open() const;
+    void close();
+    bool auto_close() const { return auto_close_; }
+    void set_auto_close(bool close) { auto_close_ = close; }
+    bool strict_sync() { return true; }
+    T* component() { return storage_.get(); }
+protected:
+    using base_type::eback; using base_type::gptr; using base_type::egptr; using base_type::setg; using base_type::gbump; using base_type::pbase; using base_type::pptr; using base_type::epptr; using base_type::setp; using base_type::pbump; using base_type::underflow; using base_type::pbackfail; using base_type::xsgetn; using base_type::overflow; using base_type::xsputn; using base_type::sync; using base_type::seekoff; using base_type::seekpos;
+    direct_streambuf();
+    void close_impl(std::ios::openmode m);
+    const std::type_info& component_type() const { return typeid(T); }
+    void* component_impl() { return component(); }
+    int_type underflow();
+    int_type pbackfail(int_type c);
+    int_type overflow(int_type c);
+    pos_type seekoff( off_type off, std::ios::seekdir way,
+                      std::ios::openmode which );
+    pos_type seekpos(pos_type sp, std::ios::openmode which);
+private:
+    pos_type seek_impl( stream_offset off, std::ios::seekdir way,
+                        std::ios::openmode which );
+    void init_input(any_tag) { }
+    void init_input(input);
+    void init_output(any_tag) { }
+    void init_output(output);
+    void init_get_area();
+    void init_put_area();
+    bool one_head() const;
+    bool two_head() const;
+    optional<T> storage_;
+    char_type *ibeg_, *iend_, *obeg_, *oend_;
+    bool auto_close_;
+};
+template<typename T, typename Tr>
+direct_streambuf<T, Tr>::direct_streambuf()
+    : ibeg_(0), iend_(0), obeg_(0), oend_(0), auto_close_(true)
+{ this->set_true_eof(true); }
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::open
+    (const T& t, std::streamsize, std::streamsize)
+{
+    storage_.reset(t);
+    init_input(category());
+    init_output(category());
+    setg(0, 0, 0);
+    setp(0, 0);
+    this->set_needs_close();
+}
+template<typename T, typename Tr>
+bool direct_streambuf<T, Tr>::is_open() const
+{ return ibeg_ != 0 || obeg_ != 0; }
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::close()
+{
+    base_type* self = this;
+    detail::execute_all( detail::call_member_close(*self, std::ios::in),
+                         detail::call_member_close(*self, std::ios::out),
+                         detail::call_reset(storage_) );
+}
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type
+direct_streambuf<T, Tr>::underflow()
+{
+    if (!ibeg_)
+        boost::throw_exception(cant_read());
+    if (!gptr())
+        init_get_area();
+    return gptr() != iend_ ?
+        traits_type::to_int_type(*gptr()) :
+        traits_type::eof();
+}
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type
+direct_streambuf<T, Tr>::pbackfail(int_type c)
+{
+    using namespace std;
+    if (!ibeg_)
+        boost::throw_exception(cant_read());
+    if (gptr() != 0 && gptr() != ibeg_) {
+        gbump(-1);
+        if (!traits_type::eq_int_type(c, traits_type::eof()))
+            *gptr() = traits_type::to_char_type(c);
+        return traits_type::not_eof(c);
+    }
+    boost::throw_exception(bad_putback());
+}
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::int_type
+direct_streambuf<T, Tr>::overflow(int_type c)
+{
+    using namespace std;
+    if (!obeg_)
+        boost::throw_exception(std::ios::failure("no write access"));
+    if (!pptr()) init_put_area();
+    if (!traits_type::eq_int_type(c, traits_type::eof())) {
+        if (pptr() == oend_)
+            boost::throw_exception(
+                std::ios::failure("write area exhausted")
+            );
+        *pptr() = traits_type::to_char_type(c);
+        pbump(1);
+        return c;
+    }
+    return traits_type::not_eof(c);
+}
+template<typename T, typename Tr>
+inline typename direct_streambuf<T, Tr>::pos_type
+direct_streambuf<T, Tr>::seekoff
+    (off_type off, std::ios::seekdir way, std::ios::openmode which)
+{ return seek_impl(off, way, which); }
+template<typename T, typename Tr>
+inline typename direct_streambuf<T, Tr>::pos_type
+direct_streambuf<T, Tr>::seekpos
+    (pos_type sp, std::ios::openmode which)
+{
+    return seek_impl(position_to_offset(sp), std::ios::beg, which);
+}
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::close_impl(std::ios::openmode which)
+{
+    if (which == std::ios::in && ibeg_ != 0) {
+        setg(0, 0, 0);
+        ibeg_ = iend_ = 0;
+    }
+    if (which == std::ios::out && obeg_ != 0) {
+        sync();
+        setp(0, 0);
+        obeg_ = oend_ = 0;
+    }
+    boost::iostreams::close(*storage_, which);
+}
+template<typename T, typename Tr>
+typename direct_streambuf<T, Tr>::pos_type direct_streambuf<T, Tr>::seek_impl
+    (stream_offset off, std::ios::seekdir way, std::ios::openmode which)
+{
+    using namespace std;
+    std::ios::openmode both = std::ios::in | std::ios::out;
+    if (two_head() && (which & both) == both)
+        boost::throw_exception(bad_seek());
+    stream_offset result = -1;
+    bool one = one_head();
+    if (one && (pptr() != 0 || gptr()== 0))
+        init_get_area();
+    if (one || ((which & std::ios::in) != 0 && ibeg_ != 0)) {
+        if (!gptr()) setg(ibeg_, ibeg_, iend_);
+        ptrdiff_t next = 0;
+        switch (way) {
+        case std::ios::beg: next = off; break;
+        case std::ios::cur: next = (gptr() - ibeg_) + off; break;
+        case std::ios::end: next = (iend_ - ibeg_) + off; break;
+        default: (static_cast<void> (0));
+        }
+        if (next < 0 || next > (iend_ - ibeg_))
+            boost::throw_exception(bad_seek());
+        setg(ibeg_, ibeg_ + next, iend_);
+        result = next;
+    }
+    if (!one && (which & std::ios::out) != 0 && obeg_ != 0) {
+        if (!pptr()) setp(obeg_, oend_);
+        ptrdiff_t next = 0;
+        switch (way) {
+        case std::ios::beg: next = off; break;
+        case std::ios::cur: next = (pptr() - obeg_) + off; break;
+        case std::ios::end: next = (oend_ - obeg_) + off; break;
+        default: (static_cast<void> (0));
+        }
+        if (next < 0 || next > (oend_ - obeg_))
+            boost::throw_exception(bad_seek());
+        pbump(static_cast<int>(next - (pptr() - obeg_)));
+        result = next;
+    }
+    return offset_to_position(result);
+}
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_input(input)
+{
+    std::pair<char_type*, char_type*> p = input_sequence(*storage_);
+    ibeg_ = p.first;
+    iend_ = p.second;
+}
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_output(output)
+{
+    std::pair<char_type*, char_type*> p = output_sequence(*storage_);
+    obeg_ = p.first;
+    oend_ = p.second;
+}
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_get_area()
+{
+    setg(ibeg_, ibeg_, iend_);
+    if (one_head() && pptr()) {
+        gbump(static_cast<int>(pptr() - obeg_));
+        setp(0, 0);
+    }
+}
+template<typename T, typename Tr>
+void direct_streambuf<T, Tr>::init_put_area()
+{
+    setp(obeg_, oend_);
+    if (one_head() && gptr()) {
+        pbump(static_cast<int>(gptr() - ibeg_));
+        setg(0, 0, 0);
+    }
+}
+template<typename T, typename Tr>
+inline bool direct_streambuf<T, Tr>::one_head() const
+{ return ibeg_ && obeg_ && ibeg_ == obeg_; }
+template<typename T, typename Tr>
+inline bool direct_streambuf<T, Tr>::two_head() const
+{ return ibeg_ && obeg_ && ibeg_ != obeg_; }
+}
+} }
+namespace boost { namespace iostreams {
+template<typename Mode, typename Ch = char>
+struct device {
+    typedef Ch char_type;
+    struct category
+        : Mode,
+          device_tag,
+          closable_tag,
+          localizable_tag
+        { };
+    void close()
+    {
+        using namespace detail;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!is_convertible<Mode, two_sequence>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_41;
+    }
+    void close(std::ios::openmode)
+    {
+        using namespace detail;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Mode, two_sequence>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_47;
+    }
+    template<typename Locale>
+    void imbue(const Locale&) { }
+};
+template<typename Mode, typename Ch = wchar_t>
+struct wdevice : device<Mode, Ch> { };
+typedef device<input> source;
+typedef wdevice<input> wsource;
+typedef device<output> sink;
+typedef wdevice<output> wsink;
+template<typename Mode, typename Ch = char>
+struct filter {
+    typedef Ch char_type;
+    struct category
+        : Mode,
+          filter_tag,
+          closable_tag,
+          localizable_tag
+        { };
+    template<typename Device>
+    void close(Device&)
+    {
+        using namespace detail;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!is_convertible<Mode, two_sequence>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_78;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!is_convertible<Mode, dual_use>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_79;
+    }
+    template<typename Device>
+    void close(Device&, std::ios::openmode)
+    {
+        using namespace detail;
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Mode, two_sequence>::value) || (is_convertible<Mode, dual_use>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_89;
+    }
+    template<typename Locale>
+    void imbue(const Locale&) { }
+};
+template<typename Mode, typename Ch = wchar_t>
+struct wfilter : filter<Mode, Ch> { };
+typedef filter<input> input_filter;
+typedef wfilter<input> input_wfilter;
+typedef filter<output> output_filter;
+typedef wfilter<output> output_wfilter;
+typedef filter<seekable> seekable_filter;
+typedef wfilter<seekable> seekable_wfilter;
+typedef filter<dual_use> dual_use_filter;
+typedef wfilter<dual_use> dual_use_wfilter;
+template<typename Mode, typename Ch = char>
+struct multichar_filter : filter<Mode, Ch> {
+    struct category : filter<Mode, Ch>::category, multichar_tag { };
+};
+template<typename Mode, typename Ch = wchar_t>
+struct multichar_wfilter : multichar_filter<Mode, Ch> { };
+typedef multichar_filter<input> multichar_input_filter;
+typedef multichar_wfilter<input> multichar_input_wfilter;
+typedef multichar_filter<output> multichar_output_filter;
+typedef multichar_wfilter<output> multichar_output_wfilter;
+typedef multichar_filter<dual_use> multichar_dual_use_filter;
+typedef multichar_wfilter<dual_use> multichar_dual_use_wfilter;
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T>
+struct param_type {
+    typedef typename mpl::if_<is_std_io<T>, T&, const T&>::type type;
+};
+template<typename T>
+struct value_type {
+    typedef typename mpl::if_<is_std_io<T>, T&, T>::type type;
+};
+} } }
+namespace boost { namespace iostreams {
+template<typename Ch, typename Mode>
+class basic_null_device {
+public:
+    typedef Ch char_type;
+    struct category
+        : public Mode,
+          public device_tag,
+          public closable_tag
+        { };
+    std::streamsize read(Ch*, std::streamsize) { return 0; }
+    std::streamsize write(const Ch*, std::streamsize n) { return n; }
+    std::streampos seek( stream_offset, std::ios::seekdir,
+                         std::ios::openmode =
+                             std::ios::in | std::ios::out )
+    { return -1; }
+    void close() { }
+    void close(std::ios::openmode) { }
+};
+template<typename Ch>
+struct basic_null_source : private basic_null_device<Ch, input> {
+    typedef Ch char_type;
+    typedef source_tag category;
+    using basic_null_device<Ch, input>::read;
+    using basic_null_device<Ch, input>::close;
+};
+typedef basic_null_source<char> null_source;
+typedef basic_null_source<wchar_t> wnull_source;
+template<typename Ch>
+struct basic_null_sink : private basic_null_device<Ch, output> {
+    typedef Ch char_type;
+    typedef sink_tag category;
+    using basic_null_device<Ch, output>::write;
+    using basic_null_device<Ch, output>::close;
+};
+typedef basic_null_sink<char> null_sink;
+typedef basic_null_sink<wchar_t> wnull_sink;
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Category> struct device_wrapper_impl;
+template<typename Category> struct flt_wrapper_impl;
+template<typename T>
+class concept_adapter {
+private:
+    typedef typename detail::value_type<T>::type value_type;
+    typedef typename dispatch<T, input, output>::type input_tag;
+    typedef typename dispatch<T, output, input>::type output_tag;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<input_tag>,
+                flt_wrapper_impl<input_tag>
+            >::type input_impl;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<output_tag>,
+                flt_wrapper_impl<output_tag>
+            >::type output_impl;
+    typedef typename
+            mpl::if_<
+                is_device<T>,
+                device_wrapper_impl<any_tag>,
+                flt_wrapper_impl<any_tag>
+            >::type any_impl;
+public:
+    typedef typename char_type_of<T>::type char_type;
+    typedef typename category_of<T>::type category;
+    explicit concept_adapter(const reference_wrapper<T>& ref) : t_(ref.get())
+    { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_std_io<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_66; }
+    explicit concept_adapter(const T& t) : t_(t)
+    { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_std_io<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_68; }
+    T& operator*() { return t_; }
+    T* operator->() { return &t_; }
+    std::streamsize read(char_type* s, std::streamsize n)
+    { return this->read(s, n, (basic_null_source<char_type>*) 0); }
+    template<typename Source>
+    std::streamsize read(char_type* s, std::streamsize n, Source* src)
+    { return input_impl::read(t_, src, s, n); }
+    std::streamsize write(const char_type* s, std::streamsize n)
+    { return this->write(s, n, (basic_null_sink<char_type>*) 0); }
+    template<typename Sink>
+    std::streamsize write(const char_type* s, std::streamsize n, Sink* snk)
+    { return output_impl::write(t_, snk, s, n); }
+    std::streampos seek( stream_offset off, std::ios::seekdir way,
+                         std::ios::openmode which )
+    {
+        return this->seek( off, way, which,
+                           (basic_null_device<char_type, seekable>*) 0);
+    }
+    template<typename Device>
+    std::streampos seek( stream_offset off, std::ios::seekdir way,
+                         std::ios::openmode which, Device* dev )
+    { return any_impl::seek(t_, dev, off, way, which); }
+    void close(std::ios::openmode which)
+    { this->close(which, (basic_null_device<char_type, seekable>*) 0); }
+    template<typename Device>
+    void close(std::ios::openmode which, Device* dev)
+    { any_impl::close(t_, dev, which); }
+    template<typename Device>
+    bool flush( Device* dev )
+    {
+        bool result = any_impl::flush(t_, dev);
+        if (dev && dev->pubsync() == -1)
+            result = false;
+        return result;
+    }
+    template<typename Locale>
+    void imbue(const Locale& loc) { iostreams::imbue(t_, loc); }
+    std::streamsize optimal_buffer_size() const
+    { return iostreams::optimal_buffer_size(t_); }
+public:
+    concept_adapter& operator=(const concept_adapter&);
+    value_type t_;
+};
+template<>
+struct device_wrapper_impl<any_tag> {
+    template<typename Device, typename Dummy>
+    static std::streampos
+    seek( Device& dev, Dummy*, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode which )
+    {
+        typedef typename category_of<Device>::type category;
+        return seek(dev, off, way, which, category());
+    }
+    template<typename Device>
+    static std::streampos
+    seek( Device&, stream_offset, std::ios::seekdir,
+          std::ios::openmode, any_tag )
+    {
+        boost::throw_exception(cant_seek());
+    }
+    template<typename Device>
+    static std::streampos
+    seek( Device& dev, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode which,
+          random_access )
+    {
+        return iostreams::seek(dev, off, way, which);
+    }
+    template<typename Device, typename Dummy>
+    static void close(Device& dev, Dummy*, std::ios::openmode which)
+    { iostreams::close(dev, which); }
+    template<typename Device, typename Dummy>
+    static bool flush(Device& dev, Dummy*)
+    { return iostreams::flush(dev); }
+};
+template<>
+struct device_wrapper_impl<input> : device_wrapper_impl<any_tag> {
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    read( Device& dev, Dummy*, typename char_type_of<Device>::type* s,
+          std::streamsize n )
+    { return iostreams::read(dev, s, n); }
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    write( Device&, Dummy*, const typename char_type_of<Device>::type*,
+           std::streamsize )
+    { boost::throw_exception(cant_write());
+      }
+};
+template<>
+struct device_wrapper_impl<output> {
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    read(Device&, Dummy*, typename char_type_of<Device>::type*, std::streamsize)
+    { boost::throw_exception(cant_read());
+      }
+    template<typename Device, typename Dummy>
+    static std::streamsize
+    write( Device& dev, Dummy*, const typename char_type_of<Device>::type* s,
+           std::streamsize n )
+    { return iostreams::write(dev, s, n); }
+};
+template<>
+struct flt_wrapper_impl<any_tag> {
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode which )
+    {
+        typedef typename category_of<Filter>::type category;
+        return seek(f, dev, off, way, which, category());
+    }
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter&, Device*, stream_offset,
+          std::ios::seekdir, std::ios::openmode, any_tag )
+    { boost::throw_exception(cant_seek());
+      }
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode which,
+          random_access tag )
+    {
+        typedef typename category_of<Filter>::type category;
+        return seek(f, dev, off, way, which, tag, category());
+    }
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode,
+          random_access, any_tag )
+    { return f.seek(*dev, off, way); }
+    template<typename Filter, typename Device>
+    static std::streampos
+    seek( Filter& f, Device* dev, stream_offset off,
+          std::ios::seekdir way, std::ios::openmode which,
+          random_access, two_sequence )
+    { return f.seek(*dev, off, way, which); }
+    template<typename Filter, typename Device>
+    static void close(Filter& f, Device* dev, std::ios::openmode which)
+    { iostreams::close(f, *dev, which); }
+    template<typename Filter, typename Device>
+    static bool flush(Filter& f, Device* dev)
+    { return iostreams::flush(f, *dev); }
+};
+template<>
+struct flt_wrapper_impl<input> {
+    template<typename Filter, typename Source>
+    static std::streamsize
+    read( Filter& f, Source* src, typename char_type_of<Filter>::type* s,
+          std::streamsize n )
+    { return iostreams::read(f, *src, s, n); }
+    template<typename Filter, typename Sink>
+    static std::streamsize
+    write( Filter&, Sink*, const typename char_type_of<Filter>::type*,
+           std::streamsize )
+    { boost::throw_exception(cant_write());
+      }
+};
+template<>
+struct flt_wrapper_impl<output> {
+    template<typename Filter, typename Source>
+    static std::streamsize
+    read(Filter&, Source*, typename char_type_of<Filter>::type*,std::streamsize)
+    { boost::throw_exception(cant_read());
+      }
+    template<typename Filter, typename Sink>
+    static std::streamsize
+    write( Filter& f, Sink* snk, const typename char_type_of<Filter>::type* s,
+           std::streamsize n )
+    { return iostreams::write(f, *snk, s, n); }
+};
+} } }
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename T>
+struct read_write_if_impl;
+template<typename T>
+struct seek_if_impl;
+}
+template<typename T>
+typename int_type_of<T>::type get_if(T& t)
+{
+    typedef typename detail::dispatch<T, input, output>::type tag;
+    return detail::read_write_if_impl<tag>::get(t);
+}
+template<typename T>
+inline std::streamsize
+read_if(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+{
+    typedef typename detail::dispatch<T, input, output>::type tag;
+    return detail::read_write_if_impl<tag>::read(t, s, n);
+}
+template<typename T>
+bool put_if(T& t, typename char_type_of<T>::type c)
+{
+    typedef typename detail::dispatch<T, output, input>::type tag;
+    return detail::read_write_if_impl<tag>::put(t, c);
+}
+template<typename T>
+inline std::streamsize write_if
+    (T& t, const typename char_type_of<T>::type* s, std::streamsize n)
+{
+    typedef typename detail::dispatch<T, output, input>::type tag;
+    return detail::read_write_if_impl<tag>::write(t, s, n);
+}
+template<typename T>
+inline std::streampos
+seek_if( T& t, stream_offset off, std::ios::seekdir way,
+         std::ios::openmode which = std::ios::in | std::ios::out )
+{
+    using namespace detail;
+    typedef typename dispatch<T, random_access, any_tag>::type tag;
+    return seek_if_impl<tag>::seek(t, off, way, which);
+}
+namespace detail {
+template<>
+struct read_write_if_impl<input> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T& t)
+    { return iostreams::get(t); }
+    template<typename T>
+    static std::streamsize
+    read(T& t, typename char_type_of<T>::type* s, std::streamsize n)
+    { return iostreams::read(t, s, n); }
+    template<typename T>
+    static bool put(T&, typename char_type_of<T>::type)
+    { boost::throw_exception(cant_write());
+      }
+    template<typename T>
+    static std::streamsize
+    write(T&, const typename char_type_of<T>::type*, std::streamsize)
+    { boost::throw_exception(cant_write());
+      }
+};
+template<>
+struct read_write_if_impl<output> {
+    template<typename T>
+    static typename int_type_of<T>::type get(T&)
+    { boost::throw_exception(cant_read());
+      }
+    template<typename T>
+    static std::streamsize
+    read(T&, typename char_type_of<T>::type*, std::streamsize)
+    { boost::throw_exception(cant_read());
+      }
+    template<typename T>
+    static bool put(T& t, typename char_type_of<T>::type c)
+    { return iostreams::put(t, c); }
+    template<typename T>
+    static std::streamsize
+    write( T& t, const typename char_type_of<T>::type* s,
+           std::streamsize n )
+    { return iostreams::write(t, s, n); }
+};
+template<>
+struct seek_if_impl<random_access> {
+    template<typename T>
+    static std::streampos
+    seek( T& t, stream_offset off, std::ios::seekdir way,
+          std::ios::openmode which )
+    { return iostreams::seek(t, off, way, which); }
+};
+template<>
+struct seek_if_impl<any_tag> {
+    template<typename T>
+    static std::streampos
+    seek(T&, stream_offset, std::ios::seekdir, std::ios::openmode)
+    { boost::throw_exception(cant_seek());
+      }
+};
+}
+} }
+namespace boost { namespace iostreams { namespace detail {
+template< typename Ch,
+          typename Alloc = std::allocator<Ch> >
+class basic_buffer {
+private:
+    typedef typename Alloc::template rebind<Ch>::other allocator_type;
+public:
+    basic_buffer();
+    basic_buffer(int buffer_size);
+    ~basic_buffer();
+    void resize(int buffer_size);
+    Ch* begin() const { return buf_; }
+    Ch* end() const { return buf_ + size_; }
+    Ch* data() const { return buf_; }
+    std::streamsize size() const { return size_; }
+    void swap(basic_buffer& rhs);
+private:
+    basic_buffer(const basic_buffer&);
+    basic_buffer& operator=(const basic_buffer&);
+    Ch* buf_;
+    std::streamsize size_;
+};
+template<typename Ch, typename Alloc>
+void swap(basic_buffer<Ch, Alloc>& lhs, basic_buffer<Ch, Alloc>& rhs)
+{ lhs.swap(rhs); }
+template< typename Ch,
+          typename Alloc = std::allocator<Ch> >
+class buffer : public basic_buffer<Ch, Alloc> {
+private:
+    typedef basic_buffer<Ch, Alloc> base;
+public:
+    typedef iostreams::char_traits<Ch> traits_type;
+    using base::resize;
+    using base::data;
+    using base::size;
+    typedef Ch* const const_pointer;
+    buffer(int buffer_size);
+    Ch* & ptr() { return ptr_; }
+    const_pointer& ptr() const { return ptr_; }
+    Ch* & eptr() { return eptr_; }
+    const_pointer& eptr() const { return eptr_; }
+    void set(std::streamsize ptr, std::streamsize end);
+    void swap(buffer& rhs);
+    template<typename Source>
+    typename int_type_of<Source>::type fill(Source& src)
+    {
+        using namespace std;
+        std::streamsize keep;
+        if ((keep = static_cast<std::streamsize>(eptr_ - ptr_)) > 0)
+            traits_type::move(this->data(), ptr_, keep);
+        set(0, keep);
+        std::streamsize result =
+            iostreams::read(src, this->data() + keep, this->size() - keep);
+        if (result != -1)
+            this->set(0, keep + result);
+        return result == -1 ?
+            traits_type::eof() :
+                result == 0 ?
+                    traits_type::would_block() :
+                    traits_type::good();
+    }
+    template<typename Sink>
+    bool flush(Sink& dest)
+    {
+        using namespace std;
+        std::streamsize amt = static_cast<std::streamsize>(eptr_ - ptr_);
+        std::streamsize result = iostreams::write_if(dest, ptr_, amt);
+        if (result < amt) {
+            traits_type::move( this->data(),
+                               ptr_ + result,
+                               amt - result );
+        }
+        this->set(0, amt - result);
+        return result != 0;
+    }
+private:
+    Ch *ptr_, *eptr_;
+};
+template<typename Ch, typename Alloc>
+void swap(buffer<Ch, Alloc>& lhs, buffer<Ch, Alloc>& rhs)
+{ lhs.swap(rhs); }
+template<typename Ch, typename Alloc>
+basic_buffer<Ch, Alloc>::basic_buffer() : buf_(0), size_(0) { }
+template<typename Ch, typename Alloc>
+basic_buffer<Ch, Alloc>::basic_buffer(int buffer_size)
+    : buf_(static_cast<Ch*>(allocator_type().allocate(buffer_size, 0))),
+      size_(buffer_size)
+    { }
+template<typename Ch, typename Alloc>
+inline basic_buffer<Ch, Alloc>::~basic_buffer()
+{
+    if (buf_) {
+        allocator_type().deallocate(buf_,
+            static_cast<typename Alloc::size_type>(size_));
+    }
+}
+template<typename Ch, typename Alloc>
+inline void basic_buffer<Ch, Alloc>::resize(int buffer_size)
+{
+    if (size_ != buffer_size) {
+        basic_buffer<Ch, Alloc> temp(buffer_size);
+        std::swap(size_, temp.size_);
+        std::swap(buf_, temp.buf_);
+    }
+}
+template<typename Ch, typename Alloc>
+void basic_buffer<Ch, Alloc>::swap(basic_buffer& rhs)
+{
+    std::swap(buf_, rhs.buf_);
+    std::swap(size_, rhs.size_);
+}
+template<typename Ch, typename Alloc>
+buffer<Ch, Alloc>::buffer(int buffer_size)
+    : basic_buffer<Ch, Alloc>(buffer_size) { }
+template<typename Ch, typename Alloc>
+inline void buffer<Ch, Alloc>::set(std::streamsize ptr, std::streamsize end)
+{
+    ptr_ = data() + ptr;
+    eptr_ = data() + end;
+}
+template<typename Ch, typename Alloc>
+inline void buffer<Ch, Alloc>::swap(buffer& rhs)
+{
+    base::swap(rhs);
+    std::swap(ptr_, rhs.ptr_);
+    std::swap(eptr_, rhs.eptr_);
+}
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T>
+class single_object_holder {
+public:
+    typedef boost::call_traits<T> traits_type;
+    typedef typename traits_type::param_type param_type;
+    typedef typename traits_type::reference reference;
+    typedef typename traits_type::const_reference const_reference;
+    single_object_holder() { }
+    single_object_holder(param_type t) : first_(t) { }
+    reference first() { return first_; }
+    const_reference first() const { return first_; }
+    reference second() { return first_; }
+    const_reference second() const { return first_; }
+    void swap(single_object_holder& o)
+    { std::swap(first_, o.first_); }
+private:
+    T first_;
+};
+template<typename T>
+struct double_object_holder {
+public:
+    typedef boost::call_traits<T> traits_type;
+    typedef typename traits_type::param_type param_type;
+    typedef typename traits_type::reference reference;
+    typedef typename traits_type::const_reference const_reference;
+    double_object_holder() { }
+    double_object_holder(param_type t1, param_type t2)
+        : first_(t1), second_(t2) { }
+    reference first() { return first_; }
+    const_reference first() const { return first_; }
+    reference second() { return second_; }
+    const_reference second() const { return second_; }
+    void swap(double_object_holder& d)
+    {
+        std::swap(first_, d.first_);
+        std::swap(second_, d.second_);
+    }
+private:
+    T first_, second_;
+};
+template<typename T, typename IsDouble>
+class double_object
+    : public mpl::if_<
+                 IsDouble,
+                 double_object_holder<T>,
+                 single_object_holder<T>
+             >::type
+{
+private:
+    typedef typename
+            mpl::if_<
+                IsDouble,
+                double_object_holder<T>,
+                single_object_holder<T>
+            >::type base_type;
+public:
+    typedef boost::call_traits<T> traits_type;
+    typedef typename traits_type::param_type param_type;
+    typedef typename traits_type::reference reference;
+    typedef typename traits_type::const_reference const_reference;
+    double_object() : base_type() {}
+    double_object(param_type t1, param_type t2)
+        : base_type(t1, t2) { }
+    bool is_double() const { return IsDouble::value; }
+};
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Traversal> struct range_adapter_impl;
+template<typename Mode, typename Range>
+class range_adapter {
+private:
+    typedef typename Range::iterator iterator;
+    typedef boost::detail::iterator_traits<iterator> iter_traits;
+    typedef typename iter_traits::iterator_category iter_cat;
+public:
+    typedef typename Range::value_type char_type;
+    struct category : Mode, device_tag { };
+    typedef typename
+            mpl::if_<
+                is_convertible<
+                    iter_cat,
+                    std::random_access_iterator_tag
+                >,
+                std::random_access_iterator_tag,
+                std::forward_iterator_tag
+            >::type tag;
+    typedef range_adapter_impl<tag> impl;
+    explicit range_adapter(const Range& rng);
+    range_adapter(iterator first, iterator last);
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek(stream_offset off, std::ios::seekdir way);
+private:
+    iterator first_, cur_, last_;
+};
+template<typename Mode, typename Range>
+range_adapter<Mode, Range>::range_adapter(const Range& rng)
+    : first_(rng.begin()), cur_(rng.begin()), last_(rng.end()) { }
+template<typename Mode, typename Range>
+range_adapter<Mode, Range>::range_adapter(iterator first, iterator last)
+    : first_(first), cur_(first), last_(last) { }
+template<typename Mode, typename Range>
+inline std::streamsize range_adapter<Mode, Range>::read
+    (char_type* s, std::streamsize n)
+{ return impl::read(cur_, last_, s, n); }
+template<typename Mode, typename Range>
+inline std::streamsize range_adapter<Mode, Range>::write
+    (const char_type* s, std::streamsize n)
+{ return impl::write(cur_, last_, s, n); }
+template<typename Mode, typename Range>
+std::streampos range_adapter<Mode, Range>::seek
+    (stream_offset off, std::ios::seekdir way)
+{
+    impl::seek(first_, cur_, last_, off, way);
+    return offset_to_position(cur_ - first_);
+}
+template<>
+struct range_adapter_impl<std::forward_iterator_tag> {
+    template<typename Iter, typename Ch>
+    static std::streamsize read
+        (Iter& cur, Iter& last, Ch* s,std::streamsize n)
+    {
+        std::streamsize rem = n;
+        while (cur != last && rem-- > 0) *s++ = *cur++;
+        return n - rem != 0 ? n - rem : -1;
+    }
+    template<typename Iter, typename Ch>
+    static std::streamsize write
+        (Iter& cur, Iter& last, const Ch* s, std::streamsize n)
+    {
+        while (cur != last && n-- > 0) *cur++ = *s++;
+        if (cur == last && n > 0)
+            boost::throw_exception(write_area_exhausted());
+        return n;
+    }
+};
+template<>
+struct range_adapter_impl<std::random_access_iterator_tag> {
+    template<typename Iter, typename Ch>
+    static std::streamsize read
+        (Iter& cur, Iter& last, Ch* s,std::streamsize n)
+    {
+        std::streamsize result =
+            (std::min)(static_cast<std::streamsize>(last - cur), n);
+        if (result)
+            std::copy(cur, cur + result, s);
+        cur += result;
+        return result != 0 ? result : -1;
+    }
+    template<typename Iter, typename Ch>
+    static std::streamsize write
+        (Iter& cur, Iter& last, const Ch* s, std::streamsize n)
+    {
+        std::streamsize count =
+            (std::min)(static_cast<std::streamsize>(last - cur), n);
+        std::copy(s, s + count, cur);
+        cur += count;
+        if (count < n)
+            boost::throw_exception(write_area_exhausted());
+        return n;
+    }
+    template<typename Iter>
+    static void seek
+        ( Iter& first, Iter& cur, Iter& last, stream_offset off,
+          std::ios::seekdir way )
+    {
+        using namespace std;
+        switch (way) {
+        case std::ios::beg:
+            if (off > last - first || off < 0)
+                boost::throw_exception(bad_seek());
+            cur = first + off;
+            break;
+        case std::ios::cur:
+            {
+                std::ptrdiff_t newoff = cur - first + off;
+                if (newoff > last - first || newoff < 0)
+                    boost::throw_exception(bad_seek());
+                cur += off;
+                break;
+            }
+        case std::ios::end:
+            if (last - first + off < 0 || off > 0)
+                boost::throw_exception(bad_seek());
+            cur = last + off;
+            break;
+        default:
+            (static_cast<void> (0));
+        }
+    }
+};
+} } }
+namespace boost { namespace iostreams {
+template<typename Pipeline, typename Component>
+struct pipeline;
+namespace detail {
+template<typename Component>
+class pipeline_segment
+{
+public:
+    pipeline_segment(const Component& component)
+        : component_(component)
+        { }
+    template<typename Fn>
+    void for_each(Fn fn) const { fn(component_); }
+    template<typename Chain>
+    void push(Chain& chn) const { chn.push(component_); }
+private:
+    pipeline_segment operator=(const pipeline_segment&);
+    const Component& component_;
+};
+}
+template<typename Pipeline, typename Component>
+struct pipeline : Pipeline {
+    typedef Pipeline pipeline_type;
+    typedef Component component_type;
+    pipeline(const Pipeline& p, const Component& component)
+        : Pipeline(p), component_(component)
+        { }
+    template<typename Fn>
+    void for_each(Fn fn) const
+    {
+        Pipeline::for_each(fn);
+        fn(component_);
+    }
+    template<typename Chain>
+    void push(Chain& chn) const
+    {
+        Pipeline::push(chn);
+        chn.push(component_);
+    }
+    const Pipeline& tail() const { return *this; }
+    const Component& head() const { return component_; }
+private:
+    pipeline operator=(const pipeline&);
+    const Component& component_;
+};
+template<typename Pipeline, typename Filter, typename Component>
+pipeline<pipeline<Pipeline, Filter>, Component>
+operator|(const pipeline<Pipeline, Filter>& p, const Component& cmp)
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_filter<Filter>::value) == 0 ? false : true) >)> boost_static_assert_typedef_122;
+    return pipeline<pipeline<Pipeline, Filter>, Component>(p, cmp);
+}
+} }
+namespace boost { namespace detail {
+namespace is_incrementable_
+{
+  struct tag {};
+  struct any { template <class T> any(T const&); };
+  tag operator++(any const&);
+  tag operator++(any const&,int);
+  tag operator,(tag,int);
+  char (& check_(tag) )[2];
+  template <class T>
+  char check_(T const&);
+  template <class T>
+  struct impl
+  {
+      static typename boost::remove_cv<T>::type& x;
+      static const bool value = sizeof(is_incrementable_::check_((++x,0))) == 1
+       ;
+  };
+  template <class T>
+  struct postfix_impl
+  {
+      static typename boost::remove_cv<T>::type& x;
+      static const bool value = sizeof(is_incrementable_::check_((x++,0))) == 1
+       ;
+  };
+}
+template<typename T>
+struct is_incrementable
+: public ::boost::integral_constant<bool,::boost::detail::is_incrementable_::impl<T>::value>
+{
+};
+template<typename T>
+struct is_postfix_incrementable
+: public ::boost::integral_constant<bool,::boost::detail::is_incrementable_::impl<T>::value>
+{
+};
+}
+}
+namespace boost { namespace iostreams { namespace detail {
+template<typename Mode, typename T>
+class mode_adapter {
+private:
+    struct empty_base { };
+public:
+    typedef typename wrapped_type<T>::type component_type;
+    typedef typename char_type_of<T>::type char_type;
+    struct category
+        : Mode,
+          device_tag,
+          mpl::if_<is_filter<T>, filter_tag, device_tag>,
+          mpl::if_<is_filter<T>, multichar_tag, empty_base>,
+              closable_tag,
+          localizable_tag
+        { };
+    explicit mode_adapter(const component_type& t) : t_(t) { }
+    std::streamsize read(char_type* s, std::streamsize n);
+    std::streamsize write(const char_type* s, std::streamsize n);
+    std::streampos seek( stream_offset off, std::ios::seekdir way,
+                         std::ios::openmode which =
+                             std::ios::in | std::ios::out );
+    void close();
+    void close(std::ios::openmode which);
+    template<typename Source>
+    std::streamsize read(Source& src, char_type* s, std::streamsize n)
+    { return iostreams::read(t_, src, s, n); }
+    template<typename Sink>
+    std::streamsize write(Sink& snk, const char_type* s, std::streamsize n)
+    { return iostreams::write(t_, snk, s, n); }
+    template<typename Device>
+    std::streampos seek(Device& dev, stream_offset off, std::ios::seekdir way)
+    { return iostreams::seek(t_, dev, off, way); }
+    template<typename Device>
+    std::streampos seek( Device& dev, stream_offset off,
+                         std::ios::seekdir way, std::ios::openmode which )
+    { return iostreams::seek(t_, dev, off, way, which); }
+    template<typename Device>
+    void close(Device& dev)
+    { detail::close_all(t_, dev); }
+    template<typename Device>
+    void close(Device& dev, std::ios::openmode which)
+    { iostreams::close(t_, dev, which); }
+    template<typename Locale>
+    void imbue(const Locale& loc)
+    { iostreams::imbue(t_, loc); }
+private:
+    component_type t_;
+};
+template<typename Mode, typename T>
+std::streamsize mode_adapter<Mode, T>::read
+    (char_type* s, std::streamsize n)
+{ return boost::iostreams::read(t_, s, n); }
+template<typename Mode, typename T>
+std::streamsize mode_adapter<Mode, T>::write
+    (const char_type* s, std::streamsize n)
+{ return boost::iostreams::write(t_, s, n); }
+template<typename Mode, typename T>
+std::streampos mode_adapter<Mode, T>::seek
+    (stream_offset off, std::ios::seekdir way, std::ios::openmode which)
+{ return boost::iostreams::seek(t_, off, way, which); }
+    template<typename Mode, typename T>
+    void mode_adapter<Mode, T>::close()
+    { detail::close_all(t_); }
+    template<typename Mode, typename T>
+    void mode_adapter<Mode, T>::close(std::ios::openmode which)
+    { iostreams::close(t_, which); }
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Mode, typename Ch, typename OutIt>
+class output_iterator_adapter {
+public:
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Mode, output>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_26;
+    typedef Ch char_type;
+    typedef sink_tag category;
+    explicit output_iterator_adapter(OutIt out) : out_(out) { }
+    std::streamsize write(const char_type* s, std::streamsize n)
+    {
+        std::copy(s, s + n, out_);
+        return n;
+    }
+private:
+    OutIt out_;
+};
+} } }
+namespace boost { namespace iostreams { namespace detail {
+namespace is_dereferenceable_
+{
+  struct tag {};
+  struct any { template <class T> any(T const&); };
+  tag operator*(any const&);
+  tag operator,(tag,int);
+  char (& check_increment(tag) )[2];
+  template <class T>
+  char check_increment(T const&);
+  template <class T>
+  struct impl
+  {
+      static typename boost::remove_cv<T>::type& x;
+      static const bool value = sizeof(is_dereferenceable_::check_increment((*x,0))) == 1
+       ;
+  };
+}
+template<typename T>
+struct is_dereferenceable
+    : public ::boost::integral_constant<bool,is_dereferenceable_::impl<T>::value>
+{
+};
+} }
+}
+namespace boost { namespace iostreams {
+namespace detail {
+template<typename Mode, typename Ch>
+class array_adapter {
+public:
+    typedef Ch char_type;
+    typedef std::pair<char_type*, char_type*> pair_type;
+    struct category
+        : public Mode,
+          public device_tag,
+          public direct_tag
+        { };
+    array_adapter(char_type* begin, char_type* end);
+    array_adapter(char_type* begin, std::size_t length);
+    array_adapter(const char_type* begin, const char_type* end);
+    array_adapter(const char_type* begin, std::size_t length);
+    template<int N>
+    array_adapter(char_type (&ar)[N])
+        : begin_(ar), end_(ar + N)
+        { }
+    pair_type input_sequence();
+    pair_type output_sequence();
+private:
+    char_type* begin_;
+    char_type* end_;
+};
+}
+template<typename Ch> struct basic_array_source : detail::array_adapter<input_seekable, Ch> { private: typedef detail::array_adapter<input_seekable, Ch> base_type; public: typedef typename base_type::char_type char_type; typedef typename base_type::category category; basic_array_source(char_type* begin, char_type* end) : base_type(begin, end) { } basic_array_source(char_type* begin, std::size_t length) : base_type(begin, length) { } basic_array_source(const char_type* begin, const char_type* end) : base_type(begin, end) { } basic_array_source(const char_type* begin, std::size_t length) : base_type(begin, length) { } template<int N> basic_array_source(Ch (&ar)[N]) : base_type(ar) { } }; typedef basic_array_source<char> array_source; typedef basic_array_source<wchar_t> warray_source;
+template<typename Ch> struct basic_array_sink : detail::array_adapter<output_seekable, Ch> { private: typedef detail::array_adapter<output_seekable, Ch> base_type; public: typedef typename base_type::char_type char_type; typedef typename base_type::category category; basic_array_sink(char_type* begin, char_type* end) : base_type(begin, end) { } basic_array_sink(char_type* begin, std::size_t length) : base_type(begin, length) { } basic_array_sink(const char_type* begin, const char_type* end) : base_type(begin, end) { } basic_array_sink(const char_type* begin, std::size_t length) : base_type(begin, length) { } template<int N> basic_array_sink(Ch (&ar)[N]) : base_type(ar) { } }; typedef basic_array_sink<char> array_sink; typedef basic_array_sink<wchar_t> warray_sink;
+template<typename Ch> struct basic_array : detail::array_adapter<seekable, Ch> { private: typedef detail::array_adapter<seekable, Ch> base_type; public: typedef typename base_type::char_type char_type; typedef typename base_type::category category; basic_array(char_type* begin, char_type* end) : base_type(begin, end) { } basic_array(char_type* begin, std::size_t length) : base_type(begin, length) { } basic_array(const char_type* begin, const char_type* end) : base_type(begin, end) { } basic_array(const char_type* begin, std::size_t length) : base_type(begin, length) { } template<int N> basic_array(Ch (&ar)[N]) : base_type(ar) { } }; typedef basic_array<char> array; typedef basic_array<wchar_t> warray;
+namespace detail {
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (char_type* begin, char_type* end)
+    : begin_(begin), end_(end)
+    { }
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (char_type* begin, std::size_t length)
+    : begin_(begin), end_(begin + length)
+    { }
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (const char_type* begin, const char_type* end)
+    : begin_(const_cast<char_type*>(begin)),
+      end_(const_cast<char_type*>(end))
+{ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!is_convertible<Mode, output>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_117; }
+template<typename Mode, typename Ch>
+array_adapter<Mode, Ch>::array_adapter
+    (const char_type* begin, std::size_t length)
+    : begin_(const_cast<char_type*>(begin)),
+      end_(const_cast<char_type*>(begin) + length)
+{ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!is_convertible<Mode, output>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_124; }
+template<typename Mode, typename Ch>
+typename array_adapter<Mode, Ch>::pair_type
+array_adapter<Mode, Ch>::input_sequence()
+{ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Mode, input>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_129;
+  return pair_type(begin_, end_); }
+template<typename Mode, typename Ch>
+typename array_adapter<Mode, Ch>::pair_type
+array_adapter<Mode, Ch>::output_sequence()
+{ typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Mode, output>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_135;
+  return pair_type(begin_, end_); }
+}
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Mode, typename Ch, typename T>
+struct resolve_traits {
+    typedef typename
+            mpl::if_<
+                boost::detail::is_incrementable<T>,
+                output_iterator_adapter<Mode, Ch, T>,
+                const T&
+            >::type type;
+};
+template<typename Mode, typename Ch, typename T>
+typename resolve_traits<Mode, Ch, T>::type
+resolve( const T& t
+         , typename boost::disable_if< boost::iostreams::is_std_io<T> >::type* = 0
+         , typename disable_if< is_iterator_range<T> >::type* = 0
+         )
+{
+    typedef typename resolve_traits<Mode, Ch, T>::type return_type;
+    return return_type(t);
+}
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >
+resolve(std::basic_streambuf<Ch, Tr>& sb)
+{ return mode_adapter< Mode, std::basic_streambuf<Ch, Tr> >(wrap(sb)); }
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_istream<Ch, Tr> >
+resolve(std::basic_istream<Ch, Tr>& is)
+{ return mode_adapter< Mode, std::basic_istream<Ch, Tr> >(wrap(is)); }
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_ostream<Ch, Tr> >
+resolve(std::basic_ostream<Ch, Tr>& os)
+{ return mode_adapter< Mode, std::basic_ostream<Ch, Tr> >(wrap(os)); }
+template<typename Mode, typename Ch, typename Tr>
+mode_adapter< Mode, std::basic_iostream<Ch, Tr> >
+resolve(std::basic_iostream<Ch, Tr>& io)
+{ return mode_adapter< Mode, std::basic_iostream<Ch, Tr> >(wrap(io)); }
+template<typename Mode, typename Ch, std::size_t N>
+array_adapter<Mode, Ch> resolve(Ch (&array)[N])
+{ return array_adapter<Mode, Ch>(array); }
+    template<typename Mode, typename Ch, typename Iter>
+    range_adapter< Mode, boost::iterator_range<Iter> >
+    resolve(const boost::iterator_range<Iter>& rng)
+    { return range_adapter< Mode, boost::iterator_range<Iter> >(rng); }
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T, typename Tr, typename Alloc, typename Mode>
+class indirect_streambuf
+    : public linked_streambuf<typename char_type_of<T>::type, Tr>
+{
+public:
+    typedef typename char_type_of<T>::type char_type;
+    typedef Tr traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::off_type off_type; typedef typename traits_type::pos_type pos_type;
+private:
+    typedef typename category_of<T>::type category;
+    typedef concept_adapter<T> wrapper;
+    typedef detail::basic_buffer<char_type, Alloc> buffer_type;
+    typedef indirect_streambuf<T, Tr, Alloc, Mode> my_type;
+    typedef detail::linked_streambuf<char_type, traits_type> base_type;
+    typedef linked_streambuf<char_type, Tr> streambuf_type;
+public:
+    indirect_streambuf();
+    void open(const T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1);
+    bool is_open() const;
+    void close();
+    bool auto_close() const;
+    void set_auto_close(bool close);
+    bool strict_sync();
+    T* component() { return &*obj(); }
+protected:
+    using base_type::eback; using base_type::gptr; using base_type::egptr; using base_type::setg; using base_type::gbump; using base_type::pbase; using base_type::pptr; using base_type::epptr; using base_type::setp; using base_type::pbump; using base_type::underflow; using base_type::pbackfail; using base_type::xsgetn; using base_type::overflow; using base_type::xsputn; using base_type::sync; using base_type::seekoff; using base_type::seekpos;
+    void imbue(const std::locale& loc);
+    int_type underflow();
+    int_type pbackfail(int_type c);
+    int_type overflow(int_type c);
+    int sync();
+    pos_type seekoff( off_type off, std::ios::seekdir way,
+                      std::ios::openmode which );
+    pos_type seekpos(pos_type sp, std::ios::openmode which);
+    void set_next(streambuf_type* next);
+    void close_impl(std::ios::openmode m);
+    const std::type_info& component_type() const { return typeid(T); }
+    void* component_impl() { return component(); }
+private:
+    wrapper& obj() { return *storage_; }
+    streambuf_type* next() const { return next_; }
+    buffer_type& in() { return buffer_.first(); }
+    buffer_type& out() { return buffer_.second(); }
+    bool can_read() const { return is_convertible<Mode, input>::value; }
+    bool can_write() const { return is_convertible<Mode, output>::value; }
+    bool output_buffered() const { return (flags_ & f_output_buffered) != 0; }
+    bool shared_buffer() const { return is_convertible<Mode, seekable>::value; }
+    void set_flags(int f) { flags_ = f; }
+    virtual void init_get_area();
+    virtual void init_put_area();
+    pos_type seek_impl( stream_offset off, std::ios::seekdir way,
+                        std::ios::openmode which );
+    void sync_impl();
+    enum flag_type {
+        f_open = 1,
+        f_output_buffered = f_open << 1,
+        f_auto_close = f_output_buffered << 1
+    };
+    optional<wrapper> storage_;
+    streambuf_type* next_;
+    double_object<
+        buffer_type,
+        is_convertible<
+            Mode,
+            two_sequence
+        >
+    > buffer_;
+    std::streamsize pback_size_;
+    int flags_;
+};
+template<typename T, typename Tr, typename Alloc, typename Mode>
+indirect_streambuf<T, Tr, Alloc, Mode>::indirect_streambuf()
+    : next_(0), pback_size_(0), flags_(f_auto_close) { }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::open
+    (const T& t, std::streamsize buffer_size, std::streamsize pback_size)
+{
+    using namespace std;
+    buffer_size =
+        (buffer_size != -1) ?
+        buffer_size :
+        iostreams::optimal_buffer_size(t);
+    pback_size =
+        (pback_size != -1) ?
+        pback_size :
+        default_pback_buffer_size;
+    if (can_read()) {
+        pback_size_ = (std::max)(std::streamsize(2), pback_size);
+        std::streamsize size =
+            pback_size_ +
+            ( buffer_size ? buffer_size: 1 );
+        in().resize(size);
+        if (!shared_buffer())
+            init_get_area();
+    }
+    if (can_write() && !shared_buffer()) {
+        if (buffer_size != 0)
+            out().resize(buffer_size);
+        init_put_area();
+    }
+    storage_.reset(wrapper(t));
+    flags_ |= f_open;
+    if (can_write() && buffer_size > 1)
+        flags_ |= f_output_buffered;
+    this->set_true_eof(false);
+    this->set_needs_close();
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline bool indirect_streambuf<T, Tr, Alloc, Mode>::is_open() const
+{ return (flags_ & f_open) != 0; }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::close()
+{
+    using namespace std;
+    base_type* self = this;
+    detail::execute_all(
+        detail::call_member_close(*self, std::ios::in),
+        detail::call_member_close(*self, std::ios::out),
+        detail::call_reset(storage_),
+        detail::clear_flags(flags_)
+    );
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+bool indirect_streambuf<T, Tr, Alloc, Mode>::auto_close() const
+{ return (flags_ & f_auto_close) != 0; }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::set_auto_close(bool close)
+{ flags_ = (flags_ & ~f_auto_close) | (close ? f_auto_close : 0); }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::imbue(const std::locale& loc)
+{
+    if (is_open()) {
+        obj().imbue(loc);
+        if (next_)
+            next_->pubimbue(loc);
+    }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::underflow()
+{
+    using namespace std;
+    if (!gptr()) init_get_area();
+    buffer_type& buf = in();
+    if (gptr() < egptr()) return traits_type::to_int_type(*gptr());
+    std::streamsize keep =
+        (std::min)( static_cast<std::streamsize>(gptr() - eback()),
+                    pback_size_ );
+    if (keep)
+        traits_type::move( buf.data() + (pback_size_ - keep),
+                           gptr() - keep, keep );
+    setg( buf.data() + pback_size_ - keep,
+          buf.data() + pback_size_,
+          buf.data() + pback_size_ );
+    std::streamsize chars =
+        obj().read(buf.data() + pback_size_, buf.size() - pback_size_, next_);
+    if (chars == -1) {
+        this->set_true_eof(true);
+        chars = 0;
+    }
+    setg(eback(), gptr(), buf.data() + pback_size_ + chars);
+    return chars != 0 ?
+        traits_type::to_int_type(*gptr()) :
+        traits_type::eof();
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::pbackfail(int_type c)
+{
+    if (gptr() != eback()) {
+        gbump(-1);
+        if (!traits_type::eq_int_type(c, traits_type::eof()))
+            *gptr() = traits_type::to_char_type(c);
+        return traits_type::not_eof(c);
+    } else {
+        boost::throw_exception(bad_putback());
+    }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::int_type
+indirect_streambuf<T, Tr, Alloc, Mode>::overflow(int_type c)
+{
+    if ( (output_buffered() && pptr() == 0) ||
+         (shared_buffer() && gptr() != 0) )
+    {
+        init_put_area();
+    }
+    if (!traits_type::eq_int_type(c, traits_type::eof())) {
+        if (output_buffered()) {
+            if (pptr() == epptr()) {
+                sync_impl();
+                if (pptr() == epptr())
+                    return traits_type::eof();
+            }
+            *pptr() = traits_type::to_char_type(c);
+            pbump(1);
+        } else {
+            char_type d = traits_type::to_char_type(c);
+            if (obj().write(&d, 1, next_) != 1)
+                return traits_type::eof();
+        }
+    }
+    return traits_type::not_eof(c);
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+int indirect_streambuf<T, Tr, Alloc, Mode>::sync()
+{
+    try {
+        sync_impl();
+        obj().flush(next_);
+        return 0;
+    } catch (...) { return -1; }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+bool indirect_streambuf<T, Tr, Alloc, Mode>::strict_sync()
+{
+    try {
+        sync_impl();
+        return obj().flush(next_);
+    } catch (...) { return false; }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seekoff
+    (off_type off, std::ios::seekdir way, std::ios::openmode which)
+{ return seek_impl(off, way, which); }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seekpos
+    (pos_type sp, std::ios::openmode which)
+{
+    return seek_impl(position_to_offset(sp), std::ios::beg, which);
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+typename indirect_streambuf<T, Tr, Alloc, Mode>::pos_type
+indirect_streambuf<T, Tr, Alloc, Mode>::seek_impl
+    (stream_offset off, std::ios::seekdir way, std::ios::openmode which)
+{
+    if ( gptr() != 0 && way == std::ios::cur && which == std::ios::in &&
+         eback() - gptr() <= off && off <= egptr() - gptr() )
+    {
+        gbump(off);
+        return obj().seek(0, std::ios::cur, std::ios::in, next_) -
+               static_cast<off_type>(egptr() - gptr());
+    }
+    if (pptr() != 0)
+        this->pubsync();
+    if (way == std::ios::cur && gptr())
+        off -= static_cast<off_type>(egptr() - gptr());
+    setg(0, 0, 0);
+    setp(0, 0);
+    return obj().seek(off, way, which, next_);
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline void indirect_streambuf<T, Tr, Alloc, Mode>::set_next
+    (streambuf_type* next)
+{ next_ = next; }
+template<typename T, typename Tr, typename Alloc, typename Mode>
+inline void indirect_streambuf<T, Tr, Alloc, Mode>::close_impl
+    (std::ios::openmode which)
+{
+    if (which == std::ios::in && is_convertible<Mode, input>::value) {
+        setg(0, 0, 0);
+    }
+    if (which == std::ios::out && is_convertible<Mode, output>::value) {
+        sync();
+        setp(0, 0);
+    }
+    if ( !is_convertible<category, dual_use>::value ||
+         is_convertible<Mode, input>::value == (which == std::ios::in) )
+    {
+        obj().close(which, next_);
+    }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::sync_impl()
+{
+    std::streamsize avail, amt;
+    if ((avail = static_cast<std::streamsize>(pptr() - pbase())) > 0) {
+        if ((amt = obj().write(pbase(), avail, next())) == avail)
+            setp(out().begin(), out().end());
+        else {
+            const char_type* ptr = pptr();
+            setp(out().begin() + amt, out().end());
+            pbump(ptr - pptr());
+        }
+    }
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::init_get_area()
+{
+    if (shared_buffer() && pptr() != 0) {
+        sync_impl();
+        setp(0, 0);
+    }
+    setg(in().begin(), in().begin(), in().begin());
+}
+template<typename T, typename Tr, typename Alloc, typename Mode>
+void indirect_streambuf<T, Tr, Alloc, Mode>::init_put_area()
+{
+    using namespace std;
+    if (shared_buffer() && gptr() != 0)
+        setg(0, 0, 0);
+    if (output_buffered())
+        setp(out().begin(), out().end());
+    else
+        setp(0, 0);
+}
+} } }
+namespace boost { namespace iostreams { namespace detail {
+template<typename T, typename Tr, typename Alloc, typename Mode>
+struct stream_buffer_traits {
+    typedef typename
+            mpl::if_<
+                is_convertible<
+                    typename category_of<T>::type,
+                    direct_tag
+                >,
+                direct_streambuf<T, Tr>,
+                indirect_streambuf<T, Tr, Alloc, Mode>
+            >::type type;
+};
+} } }
+namespace boost { namespace iostreams {
+template< typename T,
+          typename Tr =
+              std::char_traits< typename char_type_of<T>::type >
+               ,
+          typename Alloc =
+              std::allocator<
+                  typename char_type_of<T>::type
+              >,
+          typename Mode = typename mode_of<T>::type >
+class stream_buffer
+    : public detail::stream_buffer_traits<T, Tr, Alloc, Mode>::type
+{
+private:
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_convertible< typename iostreams::category_of<T>::type, Mode >::value )) == 0 ? false : true) >)>
+ boost_static_assert_typedef_72;
+    typedef typename
+            detail::stream_buffer_traits<
+                T, Tr, Alloc, Mode
+            >::type base_type;
+public:
+    typedef typename char_type_of<T>::type char_type;
+    struct category
+        : Mode,
+          closable_tag,
+          streambuf_tag
+        { };
+    typedef Tr traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::off_type off_type; typedef typename traits_type::pos_type pos_type;
+public:
+    stream_buffer() { }
+    ~stream_buffer()
+    {
+        try {
+            if (this->is_open() && this->auto_close())
+                this->close();
+        } catch (...) { }
+    }
+    stream_buffer(const T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } stream_buffer(T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } stream_buffer(const ::boost::reference_wrapper<T>& ref , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(ref , buffer_size, pback_size); } void open(const T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } void open(T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } void open(const ::boost::reference_wrapper<T>& ref , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(ref , buffer_size, pback_size); }
+ template< typename U0> stream_buffer ( const U0 &u0 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0) ); } template< typename U100 > stream_buffer ( U100& u100 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( T ( u100 ) ); } template< typename U0 , typename U1> stream_buffer ( const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0 , u1) ); } template< typename U100 , typename U0 > stream_buffer ( U100& u100 , const U0 &u0 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( T ( u100 , u0) ); } template< typename U0 , typename U1 , typename U2> stream_buffer ( const U0 &u0 , const U1 &u1 , const U2 &u2 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0 , u1 , u2) ); } template< typename U100 , typename U0 , typename U1 > stream_buffer ( U100& u100 , const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( T ( u100 , u0 , u1) ); } template< typename U0> void open( const U0 &u0 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0) ); } template< typename U100 > void open ( U100& u100 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( u100 ); } template< typename U0 , typename U1> void open( const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0 , u1) ); } template< typename U100 , typename U0 > void open ( U100& u100 , const U0 &u0 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( u100 , u0 ); } template< typename U0 , typename U1 , typename U2> void open( const U0 &u0 , const U1 &u1 , const U2 &u2 , typename boost::disable_if< boost::is_same<U0, T> >::type* = 0) { this->open_impl ( T ( u0 , u1 , u2) ); } template< typename U100 , typename U0 , typename U1 > void open ( U100& u100 , const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U100, T> >::type* = 0) { this->open_impl ( u100 , u0 , u1 ); }
+    T& operator*() { return *this->component(); }
+    T* operator->() { return this->component(); }
+private:
+    void open_impl(const T& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1)
+        {
+            if (this->is_open())
+                boost::throw_exception(
+                    std::ios::failure("already open")
+                );
+            base_type::open(t , buffer_size, pback_size);
+        }
+};
+} }
+namespace boost { namespace iostreams { namespace detail {
+template<typename Device, typename Tr>
+struct stream_traits {
+    typedef typename char_type_of<Device>::type char_type;
+    typedef Tr traits_type;
+    typedef typename category_of<Device>::type mode;
+    typedef typename
+            iostreams::select<
+                mpl::and_<
+                    is_convertible<mode, input>,
+                    is_convertible<mode, output>
+                >,
+                std::basic_iostream< char_type, traits_type >,
+                is_convertible<mode, input>,
+                std::basic_istream< char_type, traits_type >,
+                else_,
+                std::basic_ostream< char_type, traits_type >
+            >::type stream_type;
+    typedef typename
+            iostreams::select<
+                mpl::and_<
+                    is_convertible<mode, input>,
+                    is_convertible<mode, output>
+                >,
+                iostream_tag,
+                is_convertible<mode, input>,
+                istream_tag,
+                else_,
+                ostream_tag
+            >::type stream_tag;
+};
+template< typename Device,
+          typename Tr =
+              std::char_traits< typename char_type_of<Device>::type >
+               ,
+          typename Alloc =
+              std::allocator<
+                  typename char_type_of<Device>::type
+              >,
+          typename Base =
+              typename
+              detail::stream_traits<Device, Tr>::stream_type >
+class stream_base
+    : protected base_from_member< stream_buffer<Device, Tr, Alloc> >,
+      public Base
+{
+private:
+    typedef base_from_member< stream_buffer<Device, Tr, Alloc> > pbase_type;
+    typedef typename stream_traits<Device, Tr>::stream_type stream_type;
+protected:
+    using pbase_type::member;
+public:
+    stream_base() : pbase_type(), stream_type(&member) { }
+};
+} } }
+namespace boost { namespace iostreams {
+template< typename Device,
+          typename Tr =
+              std::char_traits< typename char_type_of<Device>::type >
+               ,
+          typename Alloc =
+              std::allocator<
+                  typename char_type_of<Device>::type
+              > >
+struct stream : detail::stream_base<Device, Tr, Alloc> {
+public:
+    typedef typename char_type_of<Device>::type char_type;
+    struct category
+        : mode_of<Device>::type,
+          closable_tag,
+          detail::stream_traits<Device, Tr>::stream_tag
+        { };
+    typedef Tr traits_type; typedef typename traits_type::int_type int_type; typedef typename traits_type::off_type off_type; typedef typename traits_type::pos_type pos_type;
+private:
+    typedef typename
+            detail::stream_traits<
+                Device, Tr
+            >::stream_type stream_type;
+public:
+    stream() { }
+    stream(const Device& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } stream(Device& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } stream(const ::boost::reference_wrapper<Device>& ref , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(ref , buffer_size, pback_size); } void open(const Device& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } void open(Device& t , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(::boost::iostreams::detail::wrap(t) , buffer_size, pback_size); } void open(const ::boost::reference_wrapper<Device>& ref , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1) { this->open_impl(ref , buffer_size, pback_size); }
+ template< typename U0> stream ( const U0 &u0 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0) ); } template< typename U100 > stream ( U100& u100 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( Device ( u100 ) ); } template< typename U0 , typename U1> stream ( const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0 , u1) ); } template< typename U100 , typename U0 > stream ( U100& u100 , const U0 &u0 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( Device ( u100 , u0) ); } template< typename U0 , typename U1 , typename U2> stream ( const U0 &u0 , const U1 &u1 , const U2 &u2 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0 , u1 , u2) ); } template< typename U100 , typename U0 , typename U1 > stream ( U100& u100 , const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( Device ( u100 , u0 , u1) ); } template< typename U0> void open( const U0 &u0 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0) ); } template< typename U100 > void open ( U100& u100 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( u100 ); } template< typename U0 , typename U1> void open( const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0 , u1) ); } template< typename U100 , typename U0 > void open ( U100& u100 , const U0 &u0 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( u100 , u0 ); } template< typename U0 , typename U1 , typename U2> void open( const U0 &u0 , const U1 &u1 , const U2 &u2 , typename boost::disable_if< boost::is_same<U0, Device> >::type* = 0) { this->open_impl ( Device ( u0 , u1 , u2) ); } template< typename U100 , typename U0 , typename U1 > void open ( U100& u100 , const U0 &u0 , const U1 &u1 , typename boost::disable_if< boost::is_same<U100, Device> >::type* = 0) { this->open_impl ( u100 , u0 , u1 ); }
+    bool is_open() const { return this->member.is_open(); }
+    void close() { this->member.close(); }
+    bool auto_close() const { return this->member.auto_close(); }
+    void set_auto_close(bool close) { this->member.set_auto_close(close); }
+    bool strict_sync() { return this->member.strict_sync(); }
+    Device& operator*() { return *this->member; }
+    Device* operator->() { return &*this->member; }
+    Device* component() { return this->member.component(); }
+private:
+    void open_impl(const Device& dev , std::streamsize buffer_size = -1 , std::streamsize pback_size = -1)
+    {
+        this->clear();
+        this->member.open(dev , buffer_size, pback_size);
+    }
+};
+} }
+namespace boost { namespace spirit { namespace qi { namespace detail
+{
+    template <typename Iterator>
+    struct iterator_source
+    {
+        typedef typename
+            boost::detail::iterator_traits<Iterator>::value_type
+        char_type;
+        typedef boost::iostreams::seekable_device_tag category;
+        iterator_source (Iterator const& first_, Iterator const& last_)
+          : first(first_), last(last_), pos(0)
+        {}
+        std::streamsize read (char_type* s, std::streamsize n)
+        {
+            if (first == last)
+                return -1;
+            std::streamsize bytes_read = 0;
+            while (n--) {
+                *s = *first;
+                ++s; ++bytes_read;
+                if (++first == last)
+                    break;
+            }
+            pos += bytes_read;
+            return bytes_read;
+        }
+        std::streamsize write(const char*, std::streamsize)
+        {
+            (static_cast<void> (0));
+            return -1;
+        }
+        std::streampos seek(boost::iostreams::stream_offset, std::ios_base::seekdir way)
+        {
+            (static_cast<void> (0));
+            return pos;
+        }
+        Iterator first;
+        Iterator const& last;
+        std::streamsize pos;
+    private:
+        iterator_source& operator= (iterator_source const&);
+    };
+}}}}
+namespace boost { namespace spirit
+{
+    template <>
+    struct use_terminal<qi::domain, tag::stream>
+      : mpl::true_ {};
+    template <>
+    struct use_terminal<qi::domain, tag::wstream>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace qi
+{
+    using spirit::stream;
+    using spirit::wstream;
+    using spirit::stream_type;
+    using spirit::wstream_type;
+    template <typename Char = char, typename T = spirit::basic_hold_any<char> >
+    struct stream_parser
+      : primitive_parser<stream_parser<Char, T> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+        {
+            typedef T type;
+        };
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& , Skipper const& skipper
+          , Attribute& attr) const
+        {
+            typedef qi::detail::iterator_source<Iterator> source_device;
+            typedef boost::iostreams::stream<source_device> instream;
+            qi::skip_over(first, last, skipper);
+            instream in(first, last);
+            in >> attr;
+            if (in.good()) {
+                std::streamsize pos = in.tellg();
+                std::advance(first, pos);
+            }
+            return in.good() || in.eof();
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("stream");
+        }
+    };
+    template <typename T, typename Char = char>
+    struct typed_stream
+      : proto::terminal<stream_parser<Char, T> >::type
+    {
+    };
+    template <typename Char>
+    struct make_stream
+    {
+        typedef stream_parser<Char> result_type;
+        result_type operator()(unused_type, unused_type) const
+        {
+            return result_type();
+        }
+    };
+    template <typename Modifiers>
+    struct make_primitive<tag::stream, Modifiers> : make_stream<char> {};
+    template <typename Modifiers>
+    struct make_primitive<tag::wstream, Modifiers> : make_stream<wchar_t> {};
+}}}
+namespace boost { namespace spirit { namespace repository
+{
+    namespace tag { struct distinct { }; } typedef boost::spirit::terminal<tag::distinct> distinct_type; distinct_type const distinct = distinct_type(); inline void silence_unused_warnings_distinct() { (void) distinct; }
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Tail>
+    struct use_directive<qi::domain
+          , terminal_ex<repository::tag::distinct, fusion::vector1<Tail> > >
+      : mpl::true_ {};
+    template <>
+    struct use_lazy_directive<qi::domain, repository::tag::distinct, 1>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace repository {namespace qi
+{
+    using repository::distinct_type;
+    using repository::distinct;
+    template <typename Subject, typename Tail, typename Modifier>
+    struct distinct_parser
+      : spirit::qi::unary_parser<distinct_parser<Subject, Tail, Modifier> >
+    {
+        template <typename Context, typename Iterator>
+        struct attribute
+          : traits::attribute_of<Subject, Context, Iterator>
+        {};
+        distinct_parser(Subject const& subject, Tail const& tail)
+          : subject(subject), tail(tail) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper, Attribute& attr) const
+        {
+            Iterator iter = first;
+            spirit::qi::skip_over(iter, last, skipper);
+            if (!subject.parse(iter, last, context
+              , spirit::qi::detail::unused_skipper<Skipper>(skipper), attr))
+                return false;
+            Iterator i = iter;
+            if (tail.parse(i, last, context, unused, unused))
+                return false;
+            first = iter;
+            return true;
+        }
+        template <typename Context>
+        info what(Context& ) const
+        {
+            return info("distinct");
+        }
+        Subject subject;
+        Tail tail;
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Tail, typename Subject, typename Modifiers>
+    struct make_directive<
+        terminal_ex<repository::tag::distinct, fusion::vector1<Tail> >
+      , Subject, Modifiers>
+    {
+        typedef typename result_of::compile<qi::domain, Tail, Modifiers>::type
+            tail_type;
+        typedef repository::qi::distinct_parser<
+            Subject, tail_type, Modifiers> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, Subject const& subject
+          , Modifiers const& modifiers) const
+        {
+            return result_type(subject
+              , compile<qi::domain>(fusion::at_c<0>(term.args), modifiers));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename Tail, typename Modifier>
+    struct has_semantic_action<
+            repository::qi::distinct_parser<Subject, Tail, Modifier> >
+      : unary_has_semantic_action<Subject> {};
+}}}
+namespace boost { namespace spirit { namespace repository
+{
+    namespace tag { struct confix { }; } typedef boost::spirit::terminal<tag::confix> confix_type; confix_type const confix = confix_type(); inline void silence_unused_warnings_confix() { (void) confix; }
+}}}
+namespace boost { namespace spirit
+{
+    template <typename Prefix, typename Suffix>
+    struct use_directive<qi::domain
+          , terminal_ex<repository::tag::confix, fusion::vector2<Prefix, Suffix> > >
+      : mpl::true_ {};
+    template <>
+    struct use_lazy_directive<qi::domain, repository::tag::confix, 2>
+      : mpl::true_ {};
+}}
+namespace boost { namespace spirit { namespace repository { namespace qi
+{
+    using repository::confix_type;
+    using repository::confix;
+    template <typename Subject, typename Prefix, typename Suffix>
+    struct confix_parser
+      : spirit::qi::unary_parser<confix_parser<Subject, Prefix, Suffix> >
+    {
+        typedef Subject subject_type;
+        template <typename Context, typename Iterator>
+        struct attribute
+          : traits::attribute_of<subject_type, Context, Iterator>
+        {};
+        confix_parser(Subject const& subject, Prefix const& prefix
+              , Suffix const& suffix)
+          : subject(subject), prefix(prefix), suffix(suffix) {}
+        template <typename Iterator, typename Context
+          , typename Skipper, typename Attribute>
+        bool parse(Iterator& first, Iterator const& last
+          , Context& context, Skipper const& skipper
+          , Attribute& attr) const
+        {
+            Iterator iter = first;
+            if (!(prefix.parse(iter, last, context, skipper, unused) &&
+                subject.parse(iter, last, context, skipper, attr) &&
+                suffix.parse(iter, last, context, skipper, unused)))
+            {
+                return false;
+            }
+            first = iter;
+            return true;
+        }
+        template <typename Context>
+        info what(Context const& ctx) const
+        {
+            return info("confix", subject.what(ctx));
+        }
+        Subject subject;
+        Prefix prefix;
+        Suffix suffix;
+    };
+}}}}
+namespace boost { namespace spirit { namespace qi
+{
+    template <typename Prefix, typename Suffix, typename Subject
+      , typename Modifiers>
+    struct make_directive<
+        terminal_ex<repository::tag::confix, fusion::vector2<Prefix, Suffix> >
+      , Subject, Modifiers>
+    {
+        typedef typename
+            result_of::compile<qi::domain, Prefix, Modifiers>::type
+        prefix_type;
+        typedef typename
+            result_of::compile<qi::domain, Suffix, Modifiers>::type
+        suffix_type;
+        typedef repository::qi::confix_parser<
+            Subject, prefix_type, suffix_type> result_type;
+        template <typename Terminal>
+        result_type operator()(Terminal const& term, Subject const& subject
+          , Modifiers const& modifiers) const
+        {
+            return result_type(subject
+              , compile<qi::domain>(fusion::at_c<0>(term.args), modifiers)
+              , compile<qi::domain>(fusion::at_c<1>(term.args), modifiers));
+        }
+    };
+}}}
+namespace boost { namespace spirit { namespace traits
+{
+    template <typename Subject, typename Prefix, typename Suffix>
+    struct has_semantic_action<
+            repository::qi::confix_parser<Subject, Prefix, Suffix> >
+      : mpl::or_<
+            has_semantic_action<Subject>
+          , has_semantic_action<Prefix>
+          , has_semantic_action<Suffix>
+        > {};
+}}}
+namespace boost { namespace phoenix { namespace detail
+{
+    template <typename T>
+    struct local_reference
+    {
+        typedef T type;
+        explicit local_reference(T& t): t_(boost::addressof(t)) {}
+        operator T& () const { return *t_; }
+        local_reference& operator=(T const& x) { *t_ = x; return *this; }
+        local_reference const& operator=(T const& x) const { *t_ = x; return *this; }
+        T& get() const { return *t_; }
+        T* get_pointer() const { return t_; }
+    private:
+        T* t_;
+    };
+    template <typename T>
+    struct unwrap_local_reference
+    {
+        typedef T type;
+    };
+    template <typename T>
+    struct unwrap_local_reference<local_reference<T> >
+    {
+        typedef T type;
+    };
+}}}
+namespace boost
+{
+    struct error_cant_deduce_type {};
+}
+namespace boost { namespace type_deduction_detail
+{
+    typedef char(&bool_value_type)[1];
+    typedef char(&int_value_type)[2];
+    typedef char(&uint_value_type)[3];
+    typedef char(&double_value_type)[4];
+    typedef char(&bool_reference_type)[5];
+    typedef char(&int_reference_type)[6];
+    typedef char(&uint_reference_type)[7];
+    typedef char(&double_reference_type)[8];
+    typedef char(&x_value_type)[9];
+    typedef char(&x_reference_type)[10];
+    typedef char(&x_const_pointer_type)[11];
+    typedef char(&x_pointer_type)[12];
+    typedef char(&y_value_type)[13];
+    typedef char(&y_reference_type)[14];
+    typedef char(&y_const_pointer_type)[15];
+    typedef char(&y_pointer_type)[16];
+    typedef char(&container_reference_type)[17];
+    typedef char(&container_const_reference_type)[18];
+    typedef char(&container_mapped_type)[19];
+    typedef char(&cant_deduce_type)[20];
+    template <typename T, typename Plain = typename remove_cv<T>::type>
+    struct is_basic
+        : mpl::or_<
+            is_same<Plain, bool>
+          , is_same<Plain, int>
+          , is_same<Plain, unsigned>
+          , is_same<Plain, double>
+        > {};
+    template <typename C>
+    struct reference_type
+    {
+        typedef typename C::reference type;
+    };
+    template <typename T>
+    struct reference_type<T const>
+        : reference_type<T> {};
+    template <typename T, std::size_t N>
+    struct reference_type<T[N]>
+    {
+        typedef T& type;
+    };
+    template <typename T>
+    struct reference_type<T*>
+    {
+        typedef T& type;
+    };
+    template <typename T>
+    struct reference_type<T* const>
+    {
+        typedef T const& type;
+    };
+    template <typename C>
+    struct const_reference_type
+    {
+        typedef typename C::const_reference type;
+    };
+    template <typename C>
+    struct mapped_type
+    {
+        typedef typename C::mapped_type type;
+    };
+    struct asymmetric;
+    template <typename X, typename Y>
+    cant_deduce_type
+    test(...);
+    template <typename X, typename Y>
+    bool_value_type
+    test(bool const&);
+    template <typename X, typename Y>
+    int_value_type
+    test(int const&);
+    template <typename X, typename Y>
+    uint_value_type
+    test(unsigned const&);
+    template <typename X, typename Y>
+    double_value_type
+    test(double const&);
+    template <typename X, typename Y>
+    bool_reference_type
+    test(bool&);
+    template <typename X, typename Y>
+    int_reference_type
+    test(int&);
+    template <typename X, typename Y>
+    uint_reference_type
+    test(unsigned&);
+    template <typename X, typename Y>
+    double_reference_type
+    test(double&);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<is_basic<X>, is_const<X> >
+      , x_value_type
+    >::type
+    test(X const&);
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<X>
+      , x_reference_type
+    >::type
+    test(X&);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<X>
+          , is_const<X>
+        >
+      , x_const_pointer_type
+    >::type
+    test(X const*);
+    template <typename X, typename Y>
+    x_pointer_type
+    test(X*);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_value_type
+    >::type
+    test(Y const&);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<Y>
+          , is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_reference_type
+    >::type
+    test(Y&);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_const<Y>
+          , is_same<X, Y>
+        >
+      , y_const_pointer_type
+    >::type
+    test(Y const*);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_same<Y, asymmetric>
+          , is_same<X, Y>
+        >
+      , y_pointer_type
+    >::type
+    test(Y*);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<typename X::value_type>
+          , is_same<typename add_reference<X>::type, typename X::reference>
+        >
+      , container_reference_type
+    >::type
+    test(typename X::reference);
+    template <typename X, typename Y, typename Z>
+    typename enable_if<
+        mpl::and_<
+            mpl::or_<is_array<X>, is_pointer<X> >
+          , mpl::not_<is_basic<Z> >
+          , mpl::not_<is_same<X, Z> >
+        >
+      , container_reference_type
+    >::type
+    test(Z&);
+    template <typename X, typename Y>
+    typename disable_if<
+        mpl::or_<
+            is_basic<typename X::value_type>
+          , is_same<typename add_reference<X>::type, typename X::const_reference>
+        >
+      , container_const_reference_type
+    >::type
+    test(typename X::const_reference);
+    template <typename X, typename Y>
+    typename disable_if<
+        is_basic<typename X::mapped_type>
+      , container_mapped_type
+    >::type
+    test(typename X::mapped_type);
+    template <typename X, typename Y>
+    struct base_result_of
+    {
+        typedef typename phoenix::detail::unwrap_local_reference<X>::type x_type_;
+        typedef typename phoenix::detail::unwrap_local_reference<Y>::type y_type_;
+        typedef typename remove_reference<x_type_>::type x_type;
+        typedef typename remove_reference<y_type_>::type y_type;
+        typedef mpl::vector20<
+            mpl::identity<bool>
+          , mpl::identity<int>
+          , mpl::identity<unsigned>
+          , mpl::identity<double>
+          , mpl::identity<bool&>
+          , mpl::identity<int&>
+          , mpl::identity<unsigned&>
+          , mpl::identity<double&>
+          , mpl::identity<x_type>
+          , mpl::identity<x_type&>
+          , mpl::identity<x_type const*>
+          , mpl::identity<x_type*>
+          , mpl::identity<y_type>
+          , mpl::identity<y_type&>
+          , mpl::identity<y_type const*>
+          , mpl::identity<y_type*>
+          , reference_type<x_type>
+          , const_reference_type<x_type>
+          , mapped_type<x_type>
+          , mpl::identity<error_cant_deduce_type>
+        >
+        types;
+    };
+}}
+namespace boost { namespace phoenix
+{
+    struct negate_eval;
+    struct posit_eval;
+    struct pre_increment_eval;
+    struct pre_decrement_eval;
+    struct post_increment_eval;
+    struct post_decrement_eval;
+    struct plus_assign_eval;
+    struct minus_assign_eval;
+    struct multiplies_assign_eval;
+    struct divides_assign_eval;
+    struct modulus_assign_eval;
+    struct plus_eval;
+    struct minus_eval;
+    struct multiplies_eval;
+    struct divides_eval;
+    struct modulus_eval;
+    template <typename X> struct result_of_negate { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(-x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_posit { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(+x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_pre_increment { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(++x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_pre_decrement { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(--x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_post_increment { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(x++) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_post_decrement { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(x--) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_plus_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x += y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_minus_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x -= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_multiplies_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x *= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_divides_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x /= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_modulus_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x %= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_plus { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x + y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_minus { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x - y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_multiplies { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x * y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_divides { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x / y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_modulus { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x % y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    struct negate_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<negate_eval, x_type> , result_of_negate<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return -a0.eval(env); } };
+    struct posit_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<posit_eval, x_type> , result_of_posit<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return +a0.eval(env); } };
+    struct pre_increment_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<pre_increment_eval, x_type> , result_of_pre_increment<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return ++a0.eval(env); } };
+    struct pre_decrement_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<pre_decrement_eval, x_type> , result_of_pre_decrement<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return --a0.eval(env); } };
+    struct post_increment_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<post_increment_eval, x_type> , result_of_post_increment<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return a0.eval(env)++; } };
+    struct post_decrement_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<post_decrement_eval, x_type> , result_of_post_decrement<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return a0.eval(env)--; } };
+    struct plus_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<plus_assign_eval, x_type, y_type> , result_of_plus_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) += a1.eval(env); } };
+    struct minus_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<minus_assign_eval, x_type, y_type> , result_of_minus_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) -= a1.eval(env); } };
+    struct multiplies_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<multiplies_assign_eval, x_type, y_type> , result_of_multiplies_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) *= a1.eval(env); } };
+    struct divides_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<divides_assign_eval, x_type, y_type> , result_of_divides_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) /= a1.eval(env); } };
+    struct modulus_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<modulus_assign_eval, x_type, y_type> , result_of_modulus_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) %= a1.eval(env); } };
+    struct plus_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<plus_eval, x_type, y_type> , result_of_plus<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) + a1.eval(env); } };
+    struct minus_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<minus_eval, x_type, y_type> , result_of_minus<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) - a1.eval(env); } };
+    struct multiplies_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<multiplies_eval, x_type, y_type> , result_of_multiplies<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) * a1.eval(env); } };
+    struct divides_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<divides_eval, x_type, y_type> , result_of_divides<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) / a1.eval(env); } };
+    struct modulus_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<modulus_eval, x_type, y_type> , result_of_modulus<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) % a1.eval(env); } };
+    template <typename T0> inline actor<typename as_composite<negate_eval, actor<T0> >::type> operator - (actor<T0> const& a0) { return compose<negate_eval>(a0); }
+    template <typename T0> inline actor<typename as_composite<posit_eval, actor<T0> >::type> operator + (actor<T0> const& a0) { return compose<posit_eval>(a0); }
+    template <typename T0> inline actor<typename as_composite<pre_increment_eval, actor<T0> >::type> operator ++ (actor<T0> const& a0) { return compose<pre_increment_eval>(a0); }
+    template <typename T0> inline actor<typename as_composite<pre_decrement_eval, actor<T0> >::type> operator -- (actor<T0> const& a0) { return compose<pre_decrement_eval>(a0); }
+    template <typename T0>
+    inline actor<typename as_composite<post_increment_eval, actor<T0> >::type>
+    operator++(actor<T0> const& a0, int)
+    {
+        return compose<post_increment_eval>(a0);
+    }
+    template <typename T0>
+    inline actor<typename as_composite<post_decrement_eval, actor<T0> >::type>
+    operator--(actor<T0> const& a0, int)
+    {
+        return compose<post_decrement_eval>(a0);
+    }
+    template <typename T0, typename T1> inline actor<typename as_composite<plus_assign_eval, actor<T0>, actor<T1> >::type> operator += (actor<T0> const& a0, actor<T1> const& a1) { return compose<plus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<plus_assign_eval, actor<T0>, T1>::type> operator += (actor<T0> const& a0, T1 const& a1) { return compose<plus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<plus_assign_eval, T0, actor<T1> >::type> operator += (T0 const& a0, actor<T1> const& a1) { return compose<plus_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<minus_assign_eval, actor<T0>, actor<T1> >::type> operator -= (actor<T0> const& a0, actor<T1> const& a1) { return compose<minus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<minus_assign_eval, actor<T0>, T1>::type> operator -= (actor<T0> const& a0, T1 const& a1) { return compose<minus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<minus_assign_eval, T0, actor<T1> >::type> operator -= (T0 const& a0, actor<T1> const& a1) { return compose<minus_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<multiplies_assign_eval, actor<T0>, actor<T1> >::type> operator *= (actor<T0> const& a0, actor<T1> const& a1) { return compose<multiplies_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<multiplies_assign_eval, actor<T0>, T1>::type> operator *= (actor<T0> const& a0, T1 const& a1) { return compose<multiplies_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<multiplies_assign_eval, T0, actor<T1> >::type> operator *= (T0 const& a0, actor<T1> const& a1) { return compose<multiplies_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<divides_assign_eval, actor<T0>, actor<T1> >::type> operator /= (actor<T0> const& a0, actor<T1> const& a1) { return compose<divides_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<divides_assign_eval, actor<T0>, T1>::type> operator /= (actor<T0> const& a0, T1 const& a1) { return compose<divides_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<divides_assign_eval, T0, actor<T1> >::type> operator /= (T0 const& a0, actor<T1> const& a1) { return compose<divides_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<modulus_assign_eval, actor<T0>, actor<T1> >::type> operator %= (actor<T0> const& a0, actor<T1> const& a1) { return compose<modulus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<modulus_assign_eval, actor<T0>, T1>::type> operator %= (actor<T0> const& a0, T1 const& a1) { return compose<modulus_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<modulus_assign_eval, T0, actor<T1> >::type> operator %= (T0 const& a0, actor<T1> const& a1) { return compose<modulus_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<plus_eval, actor<T0>, actor<T1> >::type> operator + (actor<T0> const& a0, actor<T1> const& a1) { return compose<plus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<plus_eval, actor<T0>, T1>::type> operator + (actor<T0> const& a0, T1 const& a1) { return compose<plus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<plus_eval, T0, actor<T1> >::type> operator + (T0 const& a0, actor<T1> const& a1) { return compose<plus_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<minus_eval, actor<T0>, actor<T1> >::type> operator - (actor<T0> const& a0, actor<T1> const& a1) { return compose<minus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<minus_eval, actor<T0>, T1>::type> operator - (actor<T0> const& a0, T1 const& a1) { return compose<minus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<minus_eval, T0, actor<T1> >::type> operator - (T0 const& a0, actor<T1> const& a1) { return compose<minus_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<multiplies_eval, actor<T0>, actor<T1> >::type> operator * (actor<T0> const& a0, actor<T1> const& a1) { return compose<multiplies_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<multiplies_eval, actor<T0>, T1>::type> operator * (actor<T0> const& a0, T1 const& a1) { return compose<multiplies_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<multiplies_eval, T0, actor<T1> >::type> operator * (T0 const& a0, actor<T1> const& a1) { return compose<multiplies_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<divides_eval, actor<T0>, actor<T1> >::type> operator / (actor<T0> const& a0, actor<T1> const& a1) { return compose<divides_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<divides_eval, actor<T0>, T1>::type> operator / (actor<T0> const& a0, T1 const& a1) { return compose<divides_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<divides_eval, T0, actor<T1> >::type> operator / (T0 const& a0, actor<T1> const& a1) { return compose<divides_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<modulus_eval, actor<T0>, actor<T1> >::type> operator % (actor<T0> const& a0, actor<T1> const& a1) { return compose<modulus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<modulus_eval, actor<T0>, T1>::type> operator % (actor<T0> const& a0, T1 const& a1) { return compose<modulus_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<modulus_eval, T0, actor<T1> >::type> operator % (T0 const& a0, actor<T1> const& a1) { return compose<modulus_eval>(a0, a1); }
+}}
+namespace boost { namespace phoenix
+{
+    struct invert_eval;
+    struct and_assign_eval;
+    struct or_assign_eval;
+    struct xor_assign_eval;
+    struct shift_left_assign_eval;
+    struct shift_right_assign_eval;
+    struct and_eval;
+    struct or_eval;
+    struct xor_eval;
+    struct shift_left_eval;
+    struct shift_right_eval;
+    template <typename X> struct result_of_invert { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(~x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_and_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x &= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_or_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x |= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_xor_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x ^= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_shift_left_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x <<= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_shift_right_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x >>= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_and { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x & y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_or { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x | y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_xor { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x ^ y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_shift_left { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x << y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_shift_right { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x >> y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    struct invert_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<invert_eval, x_type> , result_of_invert<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return ~a0.eval(env); } };
+    template <typename T0> inline actor<typename as_composite<invert_eval, actor<T0> >::type> operator ~ (actor<T0> const& a0) { return compose<invert_eval>(a0); }
+    struct and_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<and_assign_eval, x_type, y_type> , result_of_and_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) &= a1.eval(env); } };
+    struct or_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<or_assign_eval, x_type, y_type> , result_of_or_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) |= a1.eval(env); } };
+    struct xor_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<xor_assign_eval, x_type, y_type> , result_of_xor_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) ^= a1.eval(env); } };
+    struct shift_left_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<shift_left_assign_eval, x_type, y_type> , result_of_shift_left_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) <<= a1.eval(env); } };
+    struct shift_right_assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<shift_right_assign_eval, x_type, y_type> , result_of_shift_right_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) >>= a1.eval(env); } };
+    struct and_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<and_eval, x_type, y_type> , result_of_and<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) & a1.eval(env); } };
+    struct or_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<or_eval, x_type, y_type> , result_of_or<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) | a1.eval(env); } };
+    struct xor_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<xor_eval, x_type, y_type> , result_of_xor<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) ^ a1.eval(env); } };
+    struct shift_left_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<shift_left_eval, x_type, y_type> , result_of_shift_left<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) << a1.eval(env); } };
+    struct shift_right_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<shift_right_eval, x_type, y_type> , result_of_shift_right<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) >> a1.eval(env); } };
+    template <typename T0, typename T1> inline actor<typename as_composite<and_assign_eval, actor<T0>, actor<T1> >::type> operator &= (actor<T0> const& a0, actor<T1> const& a1) { return compose<and_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<and_assign_eval, actor<T0>, T1>::type> operator &= (actor<T0> const& a0, T1 const& a1) { return compose<and_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<and_assign_eval, T0, actor<T1> >::type> operator &= (T0 const& a0, actor<T1> const& a1) { return compose<and_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<or_assign_eval, actor<T0>, actor<T1> >::type> operator |= (actor<T0> const& a0, actor<T1> const& a1) { return compose<or_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<or_assign_eval, actor<T0>, T1>::type> operator |= (actor<T0> const& a0, T1 const& a1) { return compose<or_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<or_assign_eval, T0, actor<T1> >::type> operator |= (T0 const& a0, actor<T1> const& a1) { return compose<or_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<xor_assign_eval, actor<T0>, actor<T1> >::type> operator ^= (actor<T0> const& a0, actor<T1> const& a1) { return compose<xor_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<xor_assign_eval, actor<T0>, T1>::type> operator ^= (actor<T0> const& a0, T1 const& a1) { return compose<xor_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<xor_assign_eval, T0, actor<T1> >::type> operator ^= (T0 const& a0, actor<T1> const& a1) { return compose<xor_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<shift_left_assign_eval, actor<T0>, actor<T1> >::type> operator <<= (actor<T0> const& a0, actor<T1> const& a1) { return compose<shift_left_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_left_assign_eval, actor<T0>, T1>::type> operator <<= (actor<T0> const& a0, T1 const& a1) { return compose<shift_left_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_left_assign_eval, T0, actor<T1> >::type> operator <<= (T0 const& a0, actor<T1> const& a1) { return compose<shift_left_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<shift_right_assign_eval, actor<T0>, actor<T1> >::type> operator >>= (actor<T0> const& a0, actor<T1> const& a1) { return compose<shift_right_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_right_assign_eval, actor<T0>, T1>::type> operator >>= (actor<T0> const& a0, T1 const& a1) { return compose<shift_right_assign_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_right_assign_eval, T0, actor<T1> >::type> operator >>= (T0 const& a0, actor<T1> const& a1) { return compose<shift_right_assign_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<and_eval, actor<T0>, actor<T1> >::type> operator & (actor<T0> const& a0, actor<T1> const& a1) { return compose<and_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<and_eval, actor<T0>, T1>::type> operator & (actor<T0> const& a0, T1 const& a1) { return compose<and_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<and_eval, T0, actor<T1> >::type> operator & (T0 const& a0, actor<T1> const& a1) { return compose<and_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<or_eval, actor<T0>, actor<T1> >::type> operator | (actor<T0> const& a0, actor<T1> const& a1) { return compose<or_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<or_eval, actor<T0>, T1>::type> operator | (actor<T0> const& a0, T1 const& a1) { return compose<or_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<or_eval, T0, actor<T1> >::type> operator | (T0 const& a0, actor<T1> const& a1) { return compose<or_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<xor_eval, actor<T0>, actor<T1> >::type> operator ^ (actor<T0> const& a0, actor<T1> const& a1) { return compose<xor_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<xor_eval, actor<T0>, T1>::type> operator ^ (actor<T0> const& a0, T1 const& a1) { return compose<xor_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<xor_eval, T0, actor<T1> >::type> operator ^ (T0 const& a0, actor<T1> const& a1) { return compose<xor_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<shift_left_eval, actor<T0>, actor<T1> >::type> operator << (actor<T0> const& a0, actor<T1> const& a1) { return compose<shift_left_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_left_eval, actor<T0>, T1>::type> operator << (actor<T0> const& a0, T1 const& a1) { return compose<shift_left_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_left_eval, T0, actor<T1> >::type> operator << (T0 const& a0, actor<T1> const& a1) { return compose<shift_left_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<shift_right_eval, actor<T0>, actor<T1> >::type> operator >> (actor<T0> const& a0, actor<T1> const& a1) { return compose<shift_right_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_right_eval, actor<T0>, T1>::type> operator >> (actor<T0> const& a0, T1 const& a1) { return compose<shift_right_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<shift_right_eval, T0, actor<T1> >::type> operator >> (T0 const& a0, actor<T1> const& a1) { return compose<shift_right_eval>(a0, a1); }
+}}
+namespace boost { namespace phoenix
+{
+    struct equal_to_eval;
+    struct not_equal_to_eval;
+    struct less_eval;
+    struct less_equal_eval;
+    struct greater_eval;
+    struct greater_equal_eval;
+    template <typename X, typename Y> struct result_of_equal_to { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x == y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_not_equal_to { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x != y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_less { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x < y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_less_equal { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x <= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_greater { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x > y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_greater_equal { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x >= y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    struct equal_to_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<equal_to_eval, x_type, y_type> , result_of_equal_to<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) == a1.eval(env); } };
+    struct not_equal_to_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<not_equal_to_eval, x_type, y_type> , result_of_not_equal_to<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) != a1.eval(env); } };
+    struct less_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<less_eval, x_type, y_type> , result_of_less<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) < a1.eval(env); } };
+    struct less_equal_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<less_equal_eval, x_type, y_type> , result_of_less_equal<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) <= a1.eval(env); } };
+    struct greater_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<greater_eval, x_type, y_type> , result_of_greater<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) > a1.eval(env); } };
+    struct greater_equal_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<greater_equal_eval, x_type, y_type> , result_of_greater_equal<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) >= a1.eval(env); } };
+    template <typename T0, typename T1> inline actor<typename as_composite<equal_to_eval, actor<T0>, actor<T1> >::type> operator == (actor<T0> const& a0, actor<T1> const& a1) { return compose<equal_to_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<equal_to_eval, actor<T0>, T1>::type> operator == (actor<T0> const& a0, T1 const& a1) { return compose<equal_to_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<equal_to_eval, T0, actor<T1> >::type> operator == (T0 const& a0, actor<T1> const& a1) { return compose<equal_to_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<not_equal_to_eval, actor<T0>, actor<T1> >::type> operator != (actor<T0> const& a0, actor<T1> const& a1) { return compose<not_equal_to_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<not_equal_to_eval, actor<T0>, T1>::type> operator != (actor<T0> const& a0, T1 const& a1) { return compose<not_equal_to_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<not_equal_to_eval, T0, actor<T1> >::type> operator != (T0 const& a0, actor<T1> const& a1) { return compose<not_equal_to_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<less_eval, actor<T0>, actor<T1> >::type> operator < (actor<T0> const& a0, actor<T1> const& a1) { return compose<less_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<less_eval, actor<T0>, T1>::type> operator < (actor<T0> const& a0, T1 const& a1) { return compose<less_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<less_eval, T0, actor<T1> >::type> operator < (T0 const& a0, actor<T1> const& a1) { return compose<less_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<less_equal_eval, actor<T0>, actor<T1> >::type> operator <= (actor<T0> const& a0, actor<T1> const& a1) { return compose<less_equal_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<less_equal_eval, actor<T0>, T1>::type> operator <= (actor<T0> const& a0, T1 const& a1) { return compose<less_equal_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<less_equal_eval, T0, actor<T1> >::type> operator <= (T0 const& a0, actor<T1> const& a1) { return compose<less_equal_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<greater_eval, actor<T0>, actor<T1> >::type> operator > (actor<T0> const& a0, actor<T1> const& a1) { return compose<greater_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<greater_eval, actor<T0>, T1>::type> operator > (actor<T0> const& a0, T1 const& a1) { return compose<greater_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<greater_eval, T0, actor<T1> >::type> operator > (T0 const& a0, actor<T1> const& a1) { return compose<greater_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<greater_equal_eval, actor<T0>, actor<T1> >::type> operator >= (actor<T0> const& a0, actor<T1> const& a1) { return compose<greater_equal_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<greater_equal_eval, actor<T0>, T1>::type> operator >= (actor<T0> const& a0, T1 const& a1) { return compose<greater_equal_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<greater_equal_eval, T0, actor<T1> >::type> operator >= (T0 const& a0, actor<T1> const& a1) { return compose<greater_equal_eval>(a0, a1); }
+}}
+namespace boost { namespace phoenix
+{
+    template <typename X, typename Y> struct result_of_if_else { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(true ? x : y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    struct if_else_op_eval
+    {
+        template <
+            typename Env
+          , typename Cond
+          , typename Then
+          , typename Else
+        >
+        struct result
+        {
+            typedef typename Then::template result<Env>::type then_type;
+            typedef typename Else::template result<Env>::type else_type;
+            typedef typename
+                result_of_if_else<then_type, else_type>::type
+            ite_result;
+            typedef typename
+                mpl::if_<
+                    mpl::and_<
+                        is_same<then_type, else_type>
+                      , is_reference<then_type>
+                    >
+                  , ite_result
+                  , typename remove_reference<ite_result>::type
+                >::type
+            type;
+        };
+        template <
+            typename RT
+          , typename Env
+          , typename Cond
+          , typename Then
+          , typename Else
+        >
+        static RT
+        eval(Env const& env, Cond& cond, Then& then, Else& else_)
+        {
+            return cond.eval(env) ? then.eval(env) : else_.eval(env);
+        }
+    };
+    template <typename Cond, typename Then, typename Else>
+    inline actor<typename as_composite<if_else_op_eval, Cond, Then, Else>::type>
+    if_else(Cond const& cond, Then const& then, Else const& else_)
+    {
+        return compose<if_else_op_eval>(cond, then, else_);
+    }
+}}
+namespace boost { namespace phoenix
+{
+    struct logical_not_eval;
+    struct logical_and_eval;
+    struct logical_or_eval;
+    template <typename X> struct result_of_logical_not { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(!x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_logical_and { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x && y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_logical_or { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x || y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    struct logical_not_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<logical_not_eval, x_type> , result_of_logical_not<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return !a0.eval(env); } };
+    struct logical_and_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<logical_and_eval, x_type, y_type> , result_of_logical_and<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) && a1.eval(env); } };
+    struct logical_or_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<logical_or_eval, x_type, y_type> , result_of_logical_or<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) || a1.eval(env); } };
+    template <typename T0> inline actor<typename as_composite<logical_not_eval, actor<T0> >::type> operator ! (actor<T0> const& a0) { return compose<logical_not_eval>(a0); }
+    template <typename T0, typename T1> inline actor<typename as_composite<logical_and_eval, actor<T0>, actor<T1> >::type> operator && (actor<T0> const& a0, actor<T1> const& a1) { return compose<logical_and_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<logical_and_eval, actor<T0>, T1>::type> operator && (actor<T0> const& a0, T1 const& a1) { return compose<logical_and_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<logical_and_eval, T0, actor<T1> >::type> operator && (T0 const& a0, actor<T1> const& a1) { return compose<logical_and_eval>(a0, a1); }
+    template <typename T0, typename T1> inline actor<typename as_composite<logical_or_eval, actor<T0>, actor<T1> >::type> operator || (actor<T0> const& a0, actor<T1> const& a1) { return compose<logical_or_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<logical_or_eval, actor<T0>, T1>::type> operator || (actor<T0> const& a0, T1 const& a1) { return compose<logical_or_eval>(a0, a1); } template <typename T0, typename T1> inline actor<typename as_composite<logical_or_eval, T0, actor<T1> >::type> operator || (T0 const& a0, actor<T1> const& a1) { return compose<logical_or_eval>(a0, a1); }
+}}
+namespace boost { namespace phoenix
+{
+    struct reference_eval;
+    struct dereference_eval;
+    struct assign_eval;
+    struct index_eval;
+    template <typename X> struct result_of_reference { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(&x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X> struct result_of_dereference { typedef type_deduction_detail::base_result_of<X, type_deduction_detail::asymmetric> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(*x) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_assign { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , typename base_type::y_type >(x = y) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    template <typename X, typename Y> struct result_of_index { typedef type_deduction_detail::base_result_of<X, Y> base_type; static typename base_type::x_type x; static typename base_type::y_type y; static const int size = sizeof( type_deduction_detail::test< typename base_type::x_type , type_deduction_detail::asymmetric >(x[y]) ); static const int index = (size / sizeof(char)) - 1; typedef typename mpl::at_c< typename base_type::types, index>::type id; typedef typename id::type type; };
+    namespace detail
+    {
+        template <typename T0, typename T1>
+        struct make_assign_composite
+        {
+            typedef actor<typename as_composite<assign_eval, T0, T1>::type> type;
+        };
+        template <typename T0, typename T1>
+        struct make_index_composite
+        {
+            typedef actor<typename as_composite<index_eval, T0, T1>::type> type;
+        };
+    }
+    template <typename Base>
+    template <typename T1>
+    typename detail::make_assign_composite<actor<Base>, T1>::type
+    actor<Base>::operator=(T1 const& a1) const
+    {
+        return compose<assign_eval>(*this, a1);
+    }
+    template <typename Base>
+    template <typename T1>
+    typename detail::make_index_composite<actor<Base>, T1>::type
+    actor<Base>::operator[](T1 const& a1) const
+    {
+        return compose<index_eval>(*this, a1);
+    }
+    struct reference_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<reference_eval, x_type> , result_of_reference<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return &a0.eval(env); } };
+    struct dereference_eval { template <typename Env, typename A0> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename mpl::eval_if< is_actor<x_type> , re_curry<dereference_eval, x_type> , result_of_dereference<x_type> >::type type; }; template <typename RT, typename Env, typename A0> static RT eval(Env const& env, A0& a0) { return *a0.eval(env); } };
+    template <typename T0> inline actor<typename as_composite<reference_eval, actor<T0> >::type> operator & (actor<T0> const& a0) { return compose<reference_eval>(a0); }
+    template <typename T0> inline actor<typename as_composite<dereference_eval, actor<T0> >::type> operator * (actor<T0> const& a0) { return compose<dereference_eval>(a0); }
+    struct assign_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<assign_eval, x_type, y_type> , result_of_assign<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env) = a1.eval(env); } };
+    struct index_eval { template <typename Env, typename A0, typename A1> struct result { typedef typename A0::template result<Env>::type x_type; typedef typename A1::template result<Env>::type y_type; typedef typename mpl::eval_if< mpl::or_<is_actor<x_type>, is_actor<y_type> > , re_curry<index_eval, x_type, y_type> , result_of_index<x_type, y_type> >::type type; }; template <typename RT, typename Env, typename A0, typename A1> static RT eval(Env const& env, A0& a0, A1& a1) { return a0.eval(env)[a1.eval(env)]; } };
+}}
+namespace boost { namespace phoenix { namespace detail
+{
+    typedef char(&no)[1];
+    typedef char(&yes)[2];
+    template <typename CharType, typename CharTrait>
+    yes ostream_test(std::basic_ostream<CharType, CharTrait>*);
+    no ostream_test(...);
+    template <typename CharType, typename CharTrait>
+    yes istream_test(std::basic_istream<CharType, CharTrait>*);
+    no istream_test(...);
+    template <typename T>
+    struct is_ostream
+    {
+        static T x;
+        static const bool value = sizeof(detail::ostream_test(boost::addressof(x))) == sizeof(yes)
+                                                                                     ;
+    };
+    template <typename T>
+    struct is_istream
+    {
+        static T x;
+        static const bool value = sizeof(detail::istream_test(boost::addressof(x))) == sizeof(yes)
+                                                                                     ;
+    };
+    template <typename T0, typename T1>
+    struct enable_if_ostream :
+        enable_if<
+            detail::is_ostream<T0>
+          , actor<
+                typename as_composite<
+                    shift_left_eval
+                  , actor<reference<T0> >
+                  , actor<T1>
+                >::type
+            >
+        >
+    {};
+    template <typename T0, typename T1>
+    struct enable_if_istream :
+        enable_if<
+            detail::is_istream<T0>
+          , actor<
+                typename as_composite<
+                    shift_right_eval
+                  , actor<reference<T0> >
+                  , actor<T1>
+                >::type
+            >
+        >
+    {};
+    typedef std::ios_base& (*iomanip_type)(std::ios_base&);
+    typedef std::istream& (*imanip_type)(std::istream&);
+    typedef std::ostream& (*omanip_type)(std::ostream&);
+}}}
+namespace boost { namespace phoenix
+{
+    template <typename T0, typename T1>
+    inline typename detail::enable_if_ostream<T0, T1>::type
+    operator<<(T0& a0, actor<T1> const& a1)
+    {
+        return compose<shift_left_eval>(phoenix::ref(a0), a1);
+    }
+    template <typename T0, typename T1>
+    inline typename detail::enable_if_istream<T0, T1>::type
+    operator>>(T0& a0, actor<T1> const& a1)
+    {
+        return compose<shift_right_eval>(phoenix::ref(a0), a1);
+    }
+    template <typename T1>
+    inline typename detail::enable_if_ostream<std::ostream, T1>::type
+    operator<<(std::ostream& a0, actor<T1> const& a1)
+    {
+        return compose<shift_left_eval>(phoenix::ref(a0), a1);
+    }
+    template <typename T1>
+    inline typename detail::enable_if_istream<std::istream, T1>::type
+        operator>>(std::istream& a0, actor<T1> const& a1)
+    {
+        return compose<shift_right_eval>(phoenix::ref(a0), a1);
+    }
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_left_eval, actor<T0>, detail::omanip_type>::type>
+    operator<<(actor<T0> const& a0, detail::omanip_type a1)
+    {
+        return compose<shift_left_eval>(a0, a1);
+    }
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_left_eval, actor<T0>, detail::iomanip_type>::type>
+    operator<<(actor<T0> const& a0, detail::iomanip_type a1)
+    {
+        return compose<shift_left_eval>(a0, a1);
+    }
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_right_eval, actor<T0>, detail::imanip_type>::type>
+    operator>>(actor<T0> const& a0, detail::imanip_type a1)
+    {
+        return compose<shift_right_eval>(a0, a1);
+    }
+    template <typename T0>
+    inline actor<typename as_composite<
+        shift_right_eval, actor<T0>, detail::iomanip_type>::type>
+    operator>>(actor<T0> const& a0, detail::iomanip_type a1)
+    {
+        return compose<shift_right_eval>(a0, a1);
+    }
+}}
+namespace boost {
+namespace detail {
+template<typename Function> struct function_traits_helper;
+template<typename R>
+struct function_traits_helper<R (*)(void)>
+{
+  static const unsigned arity = 0;
+  typedef R result_type;
+};
+template<typename R, typename T1>
+struct function_traits_helper<R (*)(T1)>
+{
+  static const unsigned arity = 1;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T1 argument_type;
+};
+template<typename R, typename T1, typename T2>
+struct function_traits_helper<R (*)(T1, T2)>
+{
+  static const unsigned arity = 2;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T1 first_argument_type;
+  typedef T2 second_argument_type;
+};
+template<typename R, typename T1, typename T2, typename T3>
+struct function_traits_helper<R (*)(T1, T2, T3)>
+{
+  static const unsigned arity = 3;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+struct function_traits_helper<R (*)(T1, T2, T3, T4)>
+{
+  static const unsigned arity = 4;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
+{
+  static const unsigned arity = 5;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
+{
+  static const unsigned arity = 6;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
+{
+  static const unsigned arity = 7;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
+{
+  static const unsigned arity = 8;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
+{
+  static const unsigned arity = 9;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+};
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
+{
+  static const unsigned arity = 10;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+  typedef T10 arg10_type;
+};
+}
+template<typename Function>
+struct function_traits :
+  public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
+{
+};
+}
+namespace boost { namespace phoenix {
+namespace detail
+{
+    template<typename MemFunPtr>
+    struct mem_fun_ptr_return;
+    template<typename Ret, typename Class>
+    struct mem_fun_ptr_return<Ret (Class::*)()>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class>
+    struct mem_fun_ptr_return<Ret (Class::*)() const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)>
+    {
+        typedef Ret type;
+    };
+    template<typename Ret, typename Class,
+             typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    struct mem_fun_ptr_return<Ret (Class::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const>
+    {
+        typedef Ret type;
+    };
+}
+}}
+namespace boost { namespace phoenix {
+    struct mem_fun_ptr_eval
+    {
+        template<typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 = mpl::void_ , typename Arg1 = mpl::void_ , typename Arg2 = mpl::void_ , typename Arg3 = mpl::void_ , typename Arg4 = mpl::void_ , typename Arg5 = mpl::void_ >
+        struct result
+            : detail::mem_fun_ptr_return<typename eval_result<MemFunPtrActor, Env>::type> { };
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor>
+        static typename result<Env,PtrActor,MemFunPtrActor>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))();
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env));
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 , typename Arg1>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0 , Arg1>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0 , Arg1 & arg1)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env) , arg1.eval(env));
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 , typename Arg1 , typename Arg2>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0 , Arg1 , Arg2>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0 , Arg1 & arg1 , Arg2 & arg2)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env) , arg1.eval(env) , arg2.eval(env));
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0 , Arg1 , Arg2 , Arg3>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0 , Arg1 & arg1 , Arg2 & arg2 , Arg3 & arg3)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env) , arg1.eval(env) , arg2.eval(env) , arg3.eval(env));
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0 , Arg1 , Arg2 , Arg3 , Arg4>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0 , Arg1 & arg1 , Arg2 & arg2 , Arg3 & arg3 , Arg4 & arg4)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env) , arg1.eval(env) , arg2.eval(env) , arg3.eval(env) , arg4.eval(env));
+        }
+        template<typename Rt, typename Env, typename PtrActor, typename MemFunPtrActor,
+                 typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+        static typename result<Env,PtrActor,MemFunPtrActor, Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>::type
+        eval(const Env& env, PtrActor& ptrActor, MemFunPtrActor& memFunPtrActor,
+             Arg0 & arg0 , Arg1 & arg1 , Arg2 & arg2 , Arg3 & arg3 , Arg4 & arg4 , Arg5 & arg5)
+        {
+            return (get_pointer(ptrActor.eval(env))->*memFunPtrActor.eval(env))(
+                arg0.eval(env) , arg1.eval(env) , arg2.eval(env) , arg3.eval(env) , arg4.eval(env) , arg5.eval(env));
+        }
+    };
+}}
+namespace boost { namespace phoenix {
+    template<typename Actor, typename MemFunPtr>
+    struct mem_fun_ptr_gen
+    {
+        mem_fun_ptr_gen(
+            const Actor& actor, MemFunPtr memFunPtr)
+            : mActor(actor), mMemFunPtr(memFunPtr) { }
+        actor<typename as_composite<mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type>::type>
+        operator()() const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr));
+        }
+        template< typename Arg0>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0>::type>
+        operator()(
+            const Arg0 &arg0) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0);
+        }
+        template< typename Arg0 , typename Arg1>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0 , Arg1>::type>
+        operator()(
+            const Arg0 &arg0 , const Arg1 &arg1) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0 , arg1);
+        }
+        template< typename Arg0 , typename Arg1 , typename Arg2>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0 , Arg1 , Arg2>::type>
+        operator()(
+            const Arg0 &arg0 , const Arg1 &arg1 , const Arg2 &arg2) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0 , arg1 , arg2);
+        }
+        template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0 , Arg1 , Arg2 , Arg3>::type>
+        operator()(
+            const Arg0 &arg0 , const Arg1 &arg1 , const Arg2 &arg2 , const Arg3 &arg3) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0 , arg1 , arg2 , arg3);
+        }
+        template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0 , Arg1 , Arg2 , Arg3 , Arg4>::type>
+        operator()(
+            const Arg0 &arg0 , const Arg1 &arg1 , const Arg2 &arg2 , const Arg3 &arg3 , const Arg4 &arg4) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0 , arg1 , arg2 , arg3 , arg4);
+        }
+        template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+        actor<typename as_composite<
+            mem_fun_ptr_eval, Actor, typename as_actor<MemFunPtr>::type,
+            Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>::type>
+        operator()(
+            const Arg0 &arg0 , const Arg1 &arg1 , const Arg2 &arg2 , const Arg3 &arg3 , const Arg4 &arg4 , const Arg5 &arg5) const
+        {
+            return compose<mem_fun_ptr_eval>(
+                mActor, as_actor<MemFunPtr>::convert(mMemFunPtr),
+                arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
+        }
+        Actor mActor;
+        MemFunPtr mMemFunPtr;
+    };
+}}
+namespace boost {
+    template<typename T> class shared_ptr;
+    template<typename T> class scoped_ptr;
+namespace phoenix {
+    namespace detail
+    {
+        template<typename T>
+        struct member_type;
+        template<typename Class, typename MemberType>
+        struct member_type<MemberType (Class::*)>
+        {
+            typedef MemberType type;
+        };
+    }
+    namespace meta
+    {
+        template<typename T>
+        struct pointed_type;
+        template<typename T>
+        struct pointed_type<T*>
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct pointed_type<shared_ptr<T> >
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct pointed_type<scoped_ptr<T> >
+        {
+            typedef T type;
+        };
+        template<typename T>
+        struct pointed_type<std::auto_ptr<T> >
+        {
+            typedef T type;
+        };
+    }
+    struct member_object_eval
+    {
+        template<typename Env, typename PtrActor, typename MemPtrActor>
+        struct result
+        {
+            typedef typename detail::member_type<
+                typename eval_result<MemPtrActor, Env>::type>::type member_type;
+            typedef typename meta::pointed_type<
+                typename remove_reference<
+                typename eval_result<PtrActor, Env>::type>::type>::type object_type;
+            typedef typename add_reference<
+                typename mpl::eval_if<
+                is_const<object_type>,
+                add_const<member_type>,
+                mpl::identity<member_type> >::type>::type type;
+        };
+        template<typename Rt, typename Env, typename PtrActor, typename MemPtrActor>
+        static typename result<Env,PtrActor,MemPtrActor>::type
+        eval(const Env& env, PtrActor& ptrActor, MemPtrActor& memPtrActor)
+        {
+            return get_pointer(ptrActor.eval(env))->*memPtrActor.eval(env);
+        }
+    };
+    namespace member_object
+    {
+        template<typename T0, typename MemObjPtr>
+        typename enable_if<
+            mpl::and_<is_member_pointer<MemObjPtr>, mpl::not_<is_member_function_pointer<MemObjPtr> > >,
+            actor<typename as_composite<
+            member_object_eval, actor<T0>,
+            typename as_actor<MemObjPtr>::type>::type> >::type
+        operator->*(
+            const actor<T0>& ptrActor,
+            MemObjPtr memObjPtr)
+        {
+            return compose<member_object_eval>(
+                ptrActor,
+                as_actor<MemObjPtr>::convert(memObjPtr));
+        }
+    }
+    namespace member_function
+    {
+        template<typename T0, typename MemFunPtr>
+        typename enable_if<
+            is_member_function_pointer<MemFunPtr>,
+            mem_fun_ptr_gen<actor<T0>, MemFunPtr> >::type
+        operator->*(const actor<T0>& ptrActor, MemFunPtr memFunPtr)
+        {
+            return mem_fun_ptr_gen<actor<T0>, MemFunPtr>(
+                ptrActor, memFunPtr);
+        }
+    }
+    using member_object::operator->*;
+    using member_function::operator->*;
+}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _InputIterator, typename _Tp>
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ __init = __init + *__first;
+      return __init;
+    }
+  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+        _BinaryOperation __binary_op)
+    {
+      ;
+      for (; __first != __last; ++__first)
+ __init = __binary_op(__init, *__first);
+      return __init;
+    }
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init)
+    {
+      ;
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ __init = __init + (*__first1 * *__first2);
+      return __init;
+    }
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
+    typename _BinaryOperation1, typename _BinaryOperation2>
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init,
+    _BinaryOperation1 __binary_op1,
+    _BinaryOperation2 __binary_op2)
+    {
+      ;
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+      return __init;
+    }
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+      ;
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __value + *__first;
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+      ;
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __binary_op(__value, *__first);
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    adjacent_difference(_InputIterator __first,
+   _InputIterator __last, _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+      ;
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __tmp - __value;
+   __value = (__tmp);
+ }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+    _OutputIterator
+    adjacent_difference(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+      ;
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __binary_op(__tmp, __value);
+   __value = (__tmp);
+ }
+      return ++__result;
+    }
+}
+namespace boost { namespace phoenix {
+namespace detail
+{
+  template<class R>
+  typename range_result_iterator<R>::type
+  begin_(R& r)
+  {
+      return boost::begin(r);
+  }
+}
+}}
+namespace boost { namespace phoenix {
+namespace detail
+{
+  template<class R>
+  typename range_result_iterator<R>::type
+  end_(R& r)
+  {
+      return boost::end(r);
+  }
+}
+}}
+namespace boost { namespace phoenix {
+namespace impl
+{
+    struct for_each
+    {
+        template<class R, class F>
+        struct result
+        {
+            typedef F type;
+        };
+        template<class R, class F>
+        F operator()(R& r, F fn) const
+        {
+            return std::for_each(detail::begin_(r), detail::end_(r), fn);
+        }
+    };
+    struct accumulate
+    {
+        template<class R, class I, class C = void>
+        struct result
+        {
+            typedef I type;
+        };
+        template<class R, class I>
+        typename result<R,I>::type
+        operator()(R& r, I i) const
+        {
+            return std::accumulate(detail::begin_(r), detail::end_(r), i);
+        }
+        template<class R, class I, class C>
+        typename result<R,I,C>::type
+        operator()(R& r, I i, C c) const
+        {
+            return std::accumulate(detail::begin_(r), detail::end_(r), i, c);
+        }
+    };
+}
+function<impl::for_each> const for_each = impl::for_each();
+function<impl::accumulate> const accumulate = impl::accumulate();
+}}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  inline size_t
+  __deque_buf_size(size_t __size)
+  { return (__size < 512
+     ? size_t(512 / __size) : size_t(1)); }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator
+    {
+      typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+      static size_t _S_buffer_size()
+      { return __deque_buf_size(sizeof(_Tp)); }
+      typedef std::random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Ptr pointer;
+      typedef _Ref reference;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp** _Map_pointer;
+      typedef _Deque_iterator _Self;
+      _Tp* _M_cur;
+      _Tp* _M_first;
+      _Tp* _M_last;
+      _Map_pointer _M_node;
+      _Deque_iterator(_Tp* __x, _Map_pointer __y)
+      : _M_cur(__x), _M_first(*__y),
+        _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
+      _Deque_iterator()
+      : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) { }
+      _Deque_iterator(const iterator& __x)
+      : _M_cur(__x._M_cur), _M_first(__x._M_first),
+        _M_last(__x._M_last), _M_node(__x._M_node) { }
+      reference
+      operator*() const
+      { return *_M_cur; }
+      pointer
+      operator->() const
+      { return _M_cur; }
+      _Self&
+      operator++()
+      {
+ ++_M_cur;
+ if (_M_cur == _M_last)
+   {
+     _M_set_node(_M_node + 1);
+     _M_cur = _M_first;
+   }
+ return *this;
+      }
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ ++*this;
+ return __tmp;
+      }
+      _Self&
+      operator--()
+      {
+ if (_M_cur == _M_first)
+   {
+     _M_set_node(_M_node - 1);
+     _M_cur = _M_last;
+   }
+ --_M_cur;
+ return *this;
+      }
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ --*this;
+ return __tmp;
+      }
+      _Self&
+      operator+=(difference_type __n)
+      {
+ const difference_type __offset = __n + (_M_cur - _M_first);
+ if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
+   _M_cur += __n;
+ else
+   {
+     const difference_type __node_offset =
+       __offset > 0 ? __offset / difference_type(_S_buffer_size())
+                    : -difference_type((-__offset - 1)
+           / _S_buffer_size()) - 1;
+     _M_set_node(_M_node + __node_offset);
+     _M_cur = _M_first + (__offset - __node_offset
+     * difference_type(_S_buffer_size()));
+   }
+ return *this;
+      }
+      _Self
+      operator+(difference_type __n) const
+      {
+ _Self __tmp = *this;
+ return __tmp += __n;
+      }
+      _Self&
+      operator-=(difference_type __n)
+      { return *this += -__n; }
+      _Self
+      operator-(difference_type __n) const
+      {
+ _Self __tmp = *this;
+ return __tmp -= __n;
+      }
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+      void
+      _M_set_node(_Map_pointer __new_node)
+      {
+ _M_node = __new_node;
+ _M_first = *__new_node;
+ _M_last = _M_first + difference_type(_S_buffer_size());
+      }
+    };
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return __x._M_cur == __y._M_cur; }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator==(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return __x._M_cur == __y._M_cur; }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator!=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+                                          : (__x._M_node < __y._M_node); }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator<(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return (__x._M_node == __y._M_node) ? (__x._M_cur < __y._M_cur)
+                                   : (__x._M_node < __y._M_node); }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator>(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator<=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+        const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline bool
+    operator>=(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+        const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+    operator-(const _Deque_iterator<_Tp, _Ref, _Ptr>& __x,
+       const _Deque_iterator<_Tp, _Ref, _Ptr>& __y)
+    {
+      return typename _Deque_iterator<_Tp, _Ref, _Ptr>::difference_type
+ (_Deque_iterator<_Tp, _Ref, _Ptr>::_S_buffer_size())
+ * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ + (__y._M_last - __y._M_cur);
+    }
+  template<typename _Tp, typename _RefL, typename _PtrL,
+    typename _RefR, typename _PtrR>
+    inline typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+    operator-(const _Deque_iterator<_Tp, _RefL, _PtrL>& __x,
+       const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+    {
+      return typename _Deque_iterator<_Tp, _RefL, _PtrL>::difference_type
+ (_Deque_iterator<_Tp, _RefL, _PtrL>::_S_buffer_size())
+ * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+ + (__y._M_last - __y._M_cur);
+    }
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    inline _Deque_iterator<_Tp, _Ref, _Ptr>
+    operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
+    { return __x + __n; }
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>&,
+  const _Deque_iterator<_Tp, _Tp&, _Tp*>&, const _Tp&);
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+  _Deque_iterator<_Tp, _Tp&, _Tp*>);
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*>(__first),
+         _Deque_iterator<_Tp, const _Tp&, const _Tp*>(__last),
+         __result); }
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*>,
+    _Deque_iterator<_Tp, _Tp&, _Tp*>);
+  template<typename _Tp>
+    inline _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, _Tp&, _Tp*> __first,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    { return std::copy_backward(_Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__first),
+    _Deque_iterator<_Tp,
+    const _Tp&, const _Tp*>(__last),
+    __result); }
+  template<typename _Tp, typename _Alloc>
+    class _Deque_base
+    {
+    public:
+      typedef _Alloc allocator_type;
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Tp_allocator()); }
+      typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
+      _Deque_base()
+      : _M_impl()
+      { _M_initialize_map(0); }
+      _Deque_base(size_t __num_elements)
+      : _M_impl()
+      { _M_initialize_map(__num_elements); }
+      _Deque_base(const allocator_type& __a, size_t __num_elements)
+      : _M_impl(__a)
+      { _M_initialize_map(__num_elements); }
+      _Deque_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { }
+      ~_Deque_base();
+    protected:
+      typedef typename _Alloc::template rebind<_Tp*>::other _Map_alloc_type;
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+      struct _Deque_impl
+      : public _Tp_alloc_type
+      {
+ _Tp** _M_map;
+ size_t _M_map_size;
+ iterator _M_start;
+ iterator _M_finish;
+ _Deque_impl()
+ : _Tp_alloc_type(), _M_map(0), _M_map_size(0),
+   _M_start(), _M_finish()
+ { }
+ _Deque_impl(const _Tp_alloc_type& __a)
+ : _Tp_alloc_type(__a), _M_map(0), _M_map_size(0),
+   _M_start(), _M_finish()
+ { }
+      };
+      _Tp_alloc_type&
+      _M_get_Tp_allocator()
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+      _Map_alloc_type
+      _M_get_map_allocator() const
+      { return _Map_alloc_type(_M_get_Tp_allocator()); }
+      _Tp*
+      _M_allocate_node()
+      {
+ return _M_impl._Tp_alloc_type::allocate(__deque_buf_size(sizeof(_Tp)));
+      }
+      void
+      _M_deallocate_node(_Tp* __p)
+      {
+ _M_impl._Tp_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp)));
+      }
+      _Tp**
+      _M_allocate_map(size_t __n)
+      { return _M_get_map_allocator().allocate(__n); }
+      void
+      _M_deallocate_map(_Tp** __p, size_t __n)
+      { _M_get_map_allocator().deallocate(__p, __n); }
+    protected:
+      void _M_initialize_map(size_t);
+      void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
+      void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
+      enum { _S_initial_map_size = 8 };
+      _Deque_impl _M_impl;
+    };
+  template<typename _Tp, typename _Alloc>
+    _Deque_base<_Tp, _Alloc>::
+    ~_Deque_base()
+    {
+      if (this->_M_impl._M_map)
+ {
+   _M_destroy_nodes(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_initialize_map(size_t __num_elements)
+    {
+      const size_t __num_nodes = (__num_elements/ __deque_buf_size(sizeof(_Tp))
+      + 1);
+      this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
+        size_t(__num_nodes + 2));
+      this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
+      _Tp** __nstart = (this->_M_impl._M_map
+   + (this->_M_impl._M_map_size - __num_nodes) / 2);
+      _Tp** __nfinish = __nstart + __num_nodes;
+      try
+ { _M_create_nodes(__nstart, __nfinish); }
+      catch(...)
+ {
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+   this->_M_impl._M_map = 0;
+   this->_M_impl._M_map_size = 0;
+   throw;
+ }
+      this->_M_impl._M_start._M_set_node(__nstart);
+      this->_M_impl._M_finish._M_set_node(__nfinish - 1);
+      this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
+      this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
+     + __num_elements
+     % __deque_buf_size(sizeof(_Tp)));
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
+    {
+      _Tp** __cur;
+      try
+ {
+   for (__cur = __nstart; __cur < __nfinish; ++__cur)
+     *__cur = this->_M_allocate_node();
+ }
+      catch(...)
+ {
+   _M_destroy_nodes(__nstart, __cur);
+   throw;
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish)
+    {
+      for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
+ _M_deallocate_node(*__n);
+    }
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class deque : protected _Deque_base<_Tp, _Alloc>
+    {
+      typedef typename _Alloc::value_type _Alloc_value_type;
+      typedef _Deque_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_type::pointer pointer;
+      typedef typename _Tp_alloc_type::const_pointer const_pointer;
+      typedef typename _Tp_alloc_type::reference reference;
+      typedef typename _Tp_alloc_type::const_reference const_reference;
+      typedef typename _Base::iterator iterator;
+      typedef typename _Base::const_iterator const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+    protected:
+      typedef pointer* _Map_pointer;
+      static size_t _S_buffer_size()
+      { return __deque_buf_size(sizeof(_Tp)); }
+      using _Base::_M_initialize_map;
+      using _Base::_M_create_nodes;
+      using _Base::_M_destroy_nodes;
+      using _Base::_M_allocate_node;
+      using _Base::_M_deallocate_node;
+      using _Base::_M_allocate_map;
+      using _Base::_M_deallocate_map;
+      using _Base::_M_get_Tp_allocator;
+      using _Base::_M_impl;
+    public:
+      deque()
+      : _Base() { }
+      explicit
+      deque(const allocator_type& __a)
+      : _Base(__a, 0) { }
+      explicit
+      deque(size_type __n, const value_type& __value = value_type(),
+     const allocator_type& __a = allocator_type())
+      : _Base(__a, __n)
+      { _M_fill_initialize(__value); }
+      deque(const deque& __x)
+      : _Base(__x._M_get_Tp_allocator(), __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
+        this->_M_impl._M_start,
+        _M_get_Tp_allocator()); }
+      template<typename _InputIterator>
+        deque(_InputIterator __first, _InputIterator __last,
+       const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_initialize_dispatch(__first, __last, _Integral());
+ }
+      ~deque()
+      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
+      deque&
+      operator=(const deque& __x);
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_assign_dispatch(__first, __last, _Integral());
+ }
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+      iterator
+      begin()
+      { return this->_M_impl._M_start; }
+      const_iterator
+      begin() const
+      { return this->_M_impl._M_start; }
+      iterator
+      end()
+      { return this->_M_impl._M_finish; }
+      const_iterator
+      end() const
+      { return this->_M_impl._M_finish; }
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(this->_M_impl._M_finish); }
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+      reverse_iterator
+      rend()
+      { return reverse_iterator(this->_M_impl._M_start); }
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+      size_type
+      size() const
+      { return this->_M_impl._M_finish - this->_M_impl._M_start; }
+      size_type
+      max_size() const
+      { return _M_get_Tp_allocator().max_size(); }
+      void
+      resize(size_type __new_size, value_type __x = value_type())
+      {
+ const size_type __len = size();
+ if (__new_size > __len)
+   insert(this->_M_impl._M_finish, __new_size - __len, __x);
+ else if (__new_size < __len)
+   _M_erase_at_end(this->_M_impl._M_start
+     + difference_type(__new_size));
+      }
+      bool
+      empty() const
+      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
+      reference
+      operator[](size_type __n)
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+      const_reference
+      operator[](size_type __n) const
+      { return this->_M_impl._M_start[difference_type(__n)]; }
+    protected:
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range(("deque::_M_range_check"));
+      }
+    public:
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      reference
+      front()
+      { return *begin(); }
+      const_reference
+      front() const
+      { return *begin(); }
+      reference
+      back()
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+      const_reference
+      back() const
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+      void
+      push_front(const value_type& __x)
+      {
+ if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+   {
+     this->_M_impl.construct(this->_M_impl._M_start._M_cur - 1, __x);
+     --this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_push_front_aux(__x);
+      }
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_last - 1)
+   {
+     this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __x);
+     ++this->_M_impl._M_finish._M_cur;
+   }
+ else
+   _M_push_back_aux(__x);
+      }
+      void
+      pop_front()
+      {
+ if (this->_M_impl._M_start._M_cur
+     != this->_M_impl._M_start._M_last - 1)
+   {
+     this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+     ++this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_pop_front_aux();
+      }
+      void
+      pop_back()
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_first)
+   {
+     --this->_M_impl._M_finish._M_cur;
+     this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+   }
+ else
+   _M_pop_back_aux();
+      }
+      iterator
+      insert(iterator __position, const value_type& __x);
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_insert_dispatch(__position, __first, __last, _Integral());
+ }
+      iterator
+      erase(iterator __position);
+      iterator
+      erase(iterator __first, iterator __last);
+      void
+      swap(deque& __x)
+      {
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_map, __x._M_impl._M_map);
+ std::swap(this->_M_impl._M_map_size, __x._M_impl._M_map_size);
+ std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
+          __x._M_get_Tp_allocator());
+      }
+      void
+      clear()
+      { _M_erase_at_end(begin()); }
+    protected:
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        {
+   _M_initialize_map(static_cast<size_type>(__n));
+   _M_fill_initialize(__x);
+ }
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag);
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag);
+      void
+      _M_fill_initialize(const value_type& __value);
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_assign_aux(__first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag)
+        {
+   const size_type __len = std::distance(__first, __last);
+   if (__len > size())
+     {
+       _ForwardIterator __mid = __first;
+       std::advance(__mid, size());
+       std::copy(__first, __mid, begin());
+       insert(end(), __mid, __last);
+     }
+   else
+     _M_erase_at_end(std::copy(__first, __last, begin()));
+ }
+      void
+      _M_fill_assign(size_type __n, const value_type& __val)
+      {
+ if (__n > size())
+   {
+     std::fill(begin(), end(), __val);
+     insert(end(), __n - size(), __val);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + difference_type(__n));
+     std::fill(begin(), end(), __val);
+   }
+      }
+      void _M_push_back_aux(const value_type&);
+      void _M_push_front_aux(const value_type&);
+      void _M_pop_back_aux();
+      void _M_pop_front_aux();
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos,
+      _Integer __n, _Integer __x, __true_type)
+        { _M_fill_insert(__pos, __n, __x); }
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos,
+      _InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+          _M_range_insert_aux(__pos, __first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag);
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag);
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+      iterator
+      _M_insert_aux(iterator __pos, const value_type& __x);
+      void
+      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
+      template<typename _ForwardIterator>
+        void
+        _M_insert_aux(iterator __pos,
+        _ForwardIterator __first, _ForwardIterator __last,
+        size_type __n);
+      void
+      _M_destroy_data_aux(iterator __first, iterator __last);
+      template<typename _Alloc1>
+        void
+        _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
+        { _M_destroy_data_aux(__first, __last); }
+      void
+      _M_destroy_data(iterator __first, iterator __last,
+        const std::allocator<_Tp>&)
+      {
+ if (!__has_trivial_destructor(value_type))
+   _M_destroy_data_aux(__first, __last);
+      }
+      void
+      _M_erase_at_begin(iterator __pos)
+      {
+ _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
+ _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
+ this->_M_impl._M_start = __pos;
+      }
+      void
+      _M_erase_at_end(iterator __pos)
+      {
+ _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
+ _M_destroy_nodes(__pos._M_node + 1,
+    this->_M_impl._M_finish._M_node + 1);
+ this->_M_impl._M_finish = __pos;
+      }
+      iterator
+      _M_reserve_elements_at_front(size_type __n)
+      {
+ const size_type __vacancies = this->_M_impl._M_start._M_cur
+                               - this->_M_impl._M_start._M_first;
+ if (__n > __vacancies)
+   _M_new_elements_at_front(__n - __vacancies);
+ return this->_M_impl._M_start - difference_type(__n);
+      }
+      iterator
+      _M_reserve_elements_at_back(size_type __n)
+      {
+ const size_type __vacancies = (this->_M_impl._M_finish._M_last
+           - this->_M_impl._M_finish._M_cur) - 1;
+ if (__n > __vacancies)
+   _M_new_elements_at_back(__n - __vacancies);
+ return this->_M_impl._M_finish + difference_type(__n);
+      }
+      void
+      _M_new_elements_at_front(size_type __new_elements);
+      void
+      _M_new_elements_at_back(size_type __new_elements);
+      void
+      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add + 1 > this->_M_impl._M_map_size
+     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, false);
+      }
+      void
+      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
+           - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, true);
+      }
+      void
+      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+    };
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __x,
+                         const deque<_Tp, _Alloc>& __y)
+    { return __x.size() == __y.size()
+             && std::equal(__x.begin(), __x.end(), __y.begin()); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __x,
+       const deque<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __x,
+       const deque<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __x,
+        const deque<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <typename _Tp, typename _Alloc>
+    deque<_Tp, _Alloc>&
+    deque<_Tp, _Alloc>::
+    operator=(const deque& __x)
+    {
+      const size_type __len = size();
+      if (&__x != this)
+ {
+   if (__len >= __x.size())
+     _M_erase_at_end(std::copy(__x.begin(), __x.end(),
+          this->_M_impl._M_start));
+   else
+     {
+       const_iterator __mid = __x.begin() + difference_type(__len);
+       std::copy(__x.begin(), __mid, this->_M_impl._M_start);
+       insert(this->_M_impl._M_finish, __mid, __x.end());
+     }
+ }
+      return *this;
+    }
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    insert(iterator __position, const value_type& __x)
+    {
+      if (__position._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   push_front(__x);
+   return this->_M_impl._M_start;
+ }
+      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   push_back(__x);
+   iterator __tmp = this->_M_impl._M_finish;
+   --__tmp;
+   return __tmp;
+ }
+      else
+        return _M_insert_aux(__position, __x);
+    }
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    erase(iterator __position)
+    {
+      iterator __next = __position;
+      ++__next;
+      const difference_type __index = __position - begin();
+      if (static_cast<size_type>(__index) < (size() >> 1))
+ {
+   if (__position != begin())
+     std::copy_backward(begin(), __position, __next);
+   pop_front();
+ }
+      else
+ {
+   if (__next != end())
+     std::copy(__next, end(), __position);
+   pop_back();
+ }
+      return begin() + __index;
+    }
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    erase(iterator __first, iterator __last)
+    {
+      if (__first == __last)
+ return __first;
+      else if (__first == begin() && __last == end())
+ {
+   clear();
+   return end();
+ }
+      else
+ {
+   const difference_type __n = __last - __first;
+   const difference_type __elems_before = __first - begin();
+   if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
+     {
+       if (__first != begin())
+  std::copy_backward(begin(), __first, __last);
+       _M_erase_at_begin(begin() + __n);
+     }
+   else
+     {
+       if (__last != end())
+  std::copy(__last, end(), __first);
+       _M_erase_at_end(end() - __n);
+     }
+   return begin() + __elems_before;
+ }
+    }
+  template <typename _Tp, class _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+        iterator __cur = begin();
+        for (; __first != __last && __cur != end(); ++__cur, ++__first)
+          *__cur = *__first;
+        if (__first == __last)
+          _M_erase_at_end(__cur);
+        else
+          insert(end(), __first, __last);
+      }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
+    {
+      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   try
+     {
+       std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
+       __x, _M_get_Tp_allocator());
+       this->_M_impl._M_start = __new_start;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   try
+     {
+       std::__uninitialized_fill_a(this->_M_impl._M_finish,
+       __new_finish, __x,
+       _M_get_Tp_allocator());
+       this->_M_impl._M_finish = __new_finish;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+      else
+        _M_insert_aux(__pos, __n, __x);
+    }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_initialize(const value_type& __value)
+    {
+      _Map_pointer __cur;
+      try
+        {
+          for (__cur = this->_M_impl._M_start._M_node;
+        __cur < this->_M_impl._M_finish._M_node;
+        ++__cur)
+            std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
+     __value, _M_get_Tp_allocator());
+          std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
+          this->_M_impl._M_finish._M_cur,
+          __value, _M_get_Tp_allocator());
+        }
+      catch(...)
+        {
+          std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+   _M_get_Tp_allocator());
+          throw;
+        }
+    }
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      {
+        this->_M_initialize_map(0);
+        try
+          {
+            for (; __first != __last; ++__first)
+              push_back(*__first);
+          }
+        catch(...)
+          {
+            clear();
+            throw;
+          }
+      }
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        this->_M_initialize_map(__n);
+        _Map_pointer __cur_node;
+        try
+          {
+            for (__cur_node = this->_M_impl._M_start._M_node;
+                 __cur_node < this->_M_impl._M_finish._M_node;
+                 ++__cur_node)
+       {
+  _ForwardIterator __mid = __first;
+  std::advance(__mid, _S_buffer_size());
+  std::__uninitialized_copy_a(__first, __mid, *__cur_node,
+         _M_get_Tp_allocator());
+  __first = __mid;
+       }
+            std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_finish._M_first,
+     _M_get_Tp_allocator());
+          }
+        catch(...)
+          {
+            std::_Destroy(this->_M_impl._M_start,
+     iterator(*__cur_node, __cur_node),
+     _M_get_Tp_allocator());
+            throw;
+          }
+      }
+  template<typename _Tp, typename _Alloc>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_back_aux(const value_type& __t)
+      {
+ _M_reserve_map_at_back();
+ *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
+ try
+   {
+     this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
+     this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+      + 1);
+     this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
+   }
+ catch(...)
+   {
+     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
+     throw;
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_front_aux(const value_type& __t)
+      {
+ _M_reserve_map_at_front();
+ *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
+ try
+   {
+     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
+            - 1);
+     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
+     this->_M_impl.construct(this->_M_impl._M_start._M_cur, __t);
+   }
+ catch(...)
+   {
+     ++this->_M_impl._M_start;
+     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
+     throw;
+   }
+      }
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_back_aux()
+    {
+      _M_deallocate_node(this->_M_impl._M_finish._M_first);
+      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
+      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
+      this->_M_impl.destroy(this->_M_impl._M_finish._M_cur);
+    }
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_front_aux()
+    {
+      this->_M_impl.destroy(this->_M_impl._M_start._M_cur);
+      _M_deallocate_node(this->_M_impl._M_start._M_first);
+      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
+      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
+    }
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _InputIterator __first, _InputIterator __last,
+                          std::input_iterator_tag)
+      { std::copy(__first, __last, std::inserter(*this, __pos)); }
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+                          _ForwardIterator __first, _ForwardIterator __last,
+                          std::forward_iterator_tag)
+      {
+        const size_type __n = std::distance(__first, __last);
+        if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last, __new_start,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_start = __new_start;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+        else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+   {
+     iterator __new_finish = _M_reserve_elements_at_back(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last,
+         this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_finish = __new_finish;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+     __new_finish._M_node + 1);
+  throw;
+       }
+   }
+        else
+          _M_insert_aux(__pos, __first, __last, __n);
+      }
+  template<typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos, const value_type& __x)
+      {
+ value_type __x_copy = __x;
+ difference_type __index = __pos - this->_M_impl._M_start;
+ if (static_cast<size_type>(__index) < size() / 2)
+   {
+     push_front((front()));
+     iterator __front1 = this->_M_impl._M_start;
+     ++__front1;
+     iterator __front2 = __front1;
+     ++__front2;
+     __pos = this->_M_impl._M_start + __index;
+     iterator __pos1 = __pos;
+     ++__pos1;
+     std::copy(__front2, __pos1, __front1);
+   }
+ else
+   {
+     push_back((back()));
+     iterator __back1 = this->_M_impl._M_finish;
+     --__back1;
+     iterator __back2 = __back1;
+     --__back2;
+     __pos = this->_M_impl._M_start + __index;
+     std::copy_backward(__pos, __back2, __back1);
+   }
+ *__pos = (__x_copy);
+ return __pos;
+      }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
+    {
+      const difference_type __elems_before = __pos - this->_M_impl._M_start;
+      const size_type __length = this->size();
+      value_type __x_copy = __x;
+      if (__elems_before < difference_type(__length / 2))
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   iterator __old_start = this->_M_impl._M_start;
+   __pos = this->_M_impl._M_start + __elems_before;
+   try
+     {
+       if (__elems_before >= difference_type(__n))
+  {
+    iterator __start_n = (this->_M_impl._M_start
+     + difference_type(__n));
+    std::__uninitialized_move_a(this->_M_impl._M_start,
+           __start_n, __new_start,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::copy(__start_n, __pos, __old_start);
+    std::fill(__pos - difference_type(__n), __pos, __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_move_fill(this->_M_impl._M_start,
+       __pos, __new_start,
+       this->_M_impl._M_start,
+       __x_copy,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::fill(__old_start, __pos, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   iterator __old_finish = this->_M_impl._M_finish;
+   const difference_type __elems_after =
+     difference_type(__length) - __elems_before;
+   __pos = this->_M_impl._M_finish - __elems_after;
+   try
+     {
+       if (__elems_after > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::copy_backward(__pos, __finish_n, __old_finish);
+    std::fill(__pos, __pos + difference_type(__n), __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_fill_move(this->_M_impl._M_finish,
+       __pos + difference_type(__n),
+       __x_copy, __pos,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::fill(__pos, __old_finish, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+    }
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos,
+                    _ForwardIterator __first, _ForwardIterator __last,
+                    size_type __n)
+      {
+        const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
+        const size_type __length = size();
+        if (static_cast<size_type>(__elemsbefore) < __length / 2)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     iterator __old_start = this->_M_impl._M_start;
+     __pos = this->_M_impl._M_start + __elemsbefore;
+     try
+       {
+  if (__elemsbefore >= difference_type(__n))
+    {
+      iterator __start_n = (this->_M_impl._M_start
+       + difference_type(__n));
+      std::__uninitialized_move_a(this->_M_impl._M_start,
+      __start_n, __new_start,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::copy(__start_n, __pos, __old_start);
+      std::copy(__first, __last, __pos - difference_type(__n));
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, difference_type(__n) - __elemsbefore);
+      std::__uninitialized_move_copy(this->_M_impl._M_start,
+         __pos, __first, __mid,
+         __new_start,
+         _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::copy(__mid, __last, __old_start);
+    }
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+        else
+        {
+          iterator __new_finish = _M_reserve_elements_at_back(__n);
+          iterator __old_finish = this->_M_impl._M_finish;
+          const difference_type __elemsafter =
+            difference_type(__length) - __elemsbefore;
+          __pos = this->_M_impl._M_finish - __elemsafter;
+          try
+            {
+              if (__elemsafter > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::copy_backward(__pos, __finish_n, __old_finish);
+    std::copy(__first, __last, __pos);
+  }
+              else
+  {
+    _ForwardIterator __mid = __first;
+    std::advance(__mid, __elemsafter);
+    std::__uninitialized_copy_move(__mid, __last, __pos,
+       this->_M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::copy(__first, __mid, __pos);
+  }
+            }
+          catch(...)
+            {
+              _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+              throw;
+            }
+        }
+      }
+   template<typename _Tp, typename _Alloc>
+     void
+     deque<_Tp, _Alloc>::
+     _M_destroy_data_aux(iterator __first, iterator __last)
+     {
+       for (_Map_pointer __node = __first._M_node + 1;
+     __node < __last._M_node; ++__node)
+  std::_Destroy(*__node, *__node + _S_buffer_size(),
+         _M_get_Tp_allocator());
+       if (__first._M_node != __last._M_node)
+  {
+    std::_Destroy(__first._M_cur, __first._M_last,
+    _M_get_Tp_allocator());
+    std::_Destroy(__last._M_first, __last._M_cur,
+    _M_get_Tp_allocator());
+  }
+       else
+  std::_Destroy(__first._M_cur, __last._M_cur,
+         _M_get_Tp_allocator());
+     }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_front(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_front"));
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_front(__new_nodes);
+      size_type __i;
+      try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
+        }
+      catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
+          throw;
+        }
+    }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_back(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_back"));
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_back(__new_nodes);
+      size_type __i;
+      try
+        {
+          for (__i = 1; __i <= __new_nodes; ++__i)
+            *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
+        }
+      catch(...)
+        {
+          for (size_type __j = 1; __j < __i; ++__j)
+            _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
+          throw;
+        }
+    }
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
+    {
+      const size_type __old_num_nodes
+ = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
+      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+      _Map_pointer __new_nstart;
+      if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
+ {
+   __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
+      - __new_num_nodes) / 2
+                  + (__add_at_front ? __nodes_to_add : 0);
+   if (__new_nstart < this->_M_impl._M_start._M_node)
+     std::copy(this->_M_impl._M_start._M_node,
+        this->_M_impl._M_finish._M_node + 1,
+        __new_nstart);
+   else
+     std::copy_backward(this->_M_impl._M_start._M_node,
+          this->_M_impl._M_finish._M_node + 1,
+          __new_nstart + __old_num_nodes);
+ }
+      else
+ {
+   size_type __new_map_size = this->_M_impl._M_map_size
+                              + std::max(this->_M_impl._M_map_size,
+      __nodes_to_add) + 2;
+   _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
+   __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+                  + (__add_at_front ? __nodes_to_add : 0);
+   std::copy(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1,
+      __new_nstart);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+   this->_M_impl._M_map = __new_map;
+   this->_M_impl._M_map_size = __new_map_size;
+ }
+      this->_M_impl._M_start._M_set_node(__new_nstart);
+      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+    }
+  template<typename _Tp>
+    void
+    fill(const _Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
+  const _Deque_iterator<_Tp, _Tp&, _Tp*>& __last, const _Tp& __value)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      for (typename _Self::_Map_pointer __node = __first._M_node + 1;
+           __node < __last._M_node; ++__node)
+ std::fill(*__node, *__node + _Self::_S_buffer_size(), __value);
+      if (__first._M_node != __last._M_node)
+ {
+   std::fill(__first._M_cur, __first._M_last, __value);
+   std::fill(__last._M_first, __last._M_cur, __value);
+ }
+      else
+ std::fill(__first._M_cur, __last._M_cur, __value);
+    }
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+  _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+  _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   const difference_type __clen
+     = std::min(__len, std::min(__first._M_last - __first._M_cur,
+           __result._M_last - __result._M_cur));
+   std::copy(__first._M_cur, __first._M_cur + __clen, __result._M_cur);
+   __first += __clen;
+   __result += __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+  template<typename _Tp>
+    _Deque_iterator<_Tp, _Tp&, _Tp*>
+    copy_backward(_Deque_iterator<_Tp, const _Tp&, const _Tp*> __first,
+    _Deque_iterator<_Tp, const _Tp&, const _Tp*> __last,
+    _Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef typename _Deque_iterator<_Tp, _Tp&, _Tp*>::_Self _Self;
+      typedef typename _Self::difference_type difference_type;
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   difference_type __llen = __last._M_cur - __last._M_first;
+   _Tp* __lend = __last._M_cur;
+   difference_type __rlen = __result._M_cur - __result._M_first;
+   _Tp* __rend = __result._M_cur;
+   if (!__llen)
+     {
+       __llen = _Self::_S_buffer_size();
+       __lend = *(__last._M_node - 1) + __llen;
+     }
+   if (!__rlen)
+     {
+       __rlen = _Self::_S_buffer_size();
+       __rend = *(__result._M_node - 1) + __rlen;
+     }
+   const difference_type __clen = std::min(__len,
+        std::min(__llen, __rlen));
+   std::copy_backward(__lend - __clen, __lend, __rend);
+   __last -= __clen;
+   __result -= __clen;
+   __len -= __clen;
+ }
+      return __result;
+    }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template<typename _Key, typename _Compare = std::less<_Key>,
+    typename _Alloc = std::allocator<_Key> >
+    class set
+    {
+      typedef typename _Alloc::value_type _Alloc_value_type;
+    public:
+      typedef _Key key_type;
+      typedef _Key value_type;
+      typedef _Compare key_compare;
+      typedef _Compare value_compare;
+      typedef _Alloc allocator_type;
+    private:
+      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
+      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
+         key_compare, _Key_alloc_type> _Rep_type;
+      _Rep_type _M_t;
+    public:
+      typedef typename _Key_alloc_type::pointer pointer;
+      typedef typename _Key_alloc_type::const_pointer const_pointer;
+      typedef typename _Key_alloc_type::reference reference;
+      typedef typename _Key_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::const_iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      set()
+      : _M_t() { }
+      explicit
+      set(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+      template<typename _InputIterator>
+ set(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_unique(__first, __last); }
+      template<typename _InputIterator>
+ set(_InputIterator __first, _InputIterator __last,
+     const _Compare& __comp,
+     const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a)
+ { _M_t._M_insert_unique(__first, __last); }
+      set(const set& __x)
+      : _M_t(__x._M_t) { }
+      set&
+      operator=(const set& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      value_compare
+      value_comp() const
+      { return _M_t.key_comp(); }
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+      iterator
+      begin() const
+      { return _M_t.begin(); }
+      iterator
+      end() const
+      { return _M_t.end(); }
+      reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+      reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+      bool
+      empty() const
+      { return _M_t.empty(); }
+      size_type
+      size() const
+      { return _M_t.size(); }
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+      void
+      swap(set& __x)
+      { _M_t.swap(__x._M_t); }
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      {
+ std::pair<typename _Rep_type::iterator, bool> __p =
+   _M_t._M_insert_unique(__x);
+ return std::pair<iterator, bool>(__p.first, __p.second);
+      }
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return _M_t._M_insert_unique_(__position, __x); }
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_unique(__first, __last); }
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+      void
+      clear()
+      { _M_t.clear(); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      template<typename _K1, typename _C1, typename _A1>
+ friend bool
+ operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+      template<typename _K1, typename _C1, typename _A1>
+ friend bool
+ operator<(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
+    };
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const set<_Key, _Compare, _Alloc>& __x,
+        const set<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const set<_Key, _Compare, _Alloc>& __x,
+       const set<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const set<_Key, _Compare, _Alloc>& __x,
+        const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const set<_Key, _Compare, _Alloc>& __x,
+       const set<_Key, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const set<_Key, _Compare, _Alloc>& __x,
+        const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const set<_Key, _Compare, _Alloc>& __x,
+        const set<_Key, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline void
+    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  template <typename _Key, typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<_Key> >
+    class multiset
+    {
+      typedef typename _Alloc::value_type _Alloc_value_type;
+    public:
+      typedef _Key key_type;
+      typedef _Key value_type;
+      typedef _Compare key_compare;
+      typedef _Compare value_compare;
+      typedef _Alloc allocator_type;
+    private:
+      typedef typename _Alloc::template rebind<_Key>::other _Key_alloc_type;
+      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
+         key_compare, _Key_alloc_type> _Rep_type;
+      _Rep_type _M_t;
+    public:
+      typedef typename _Key_alloc_type::pointer pointer;
+      typedef typename _Key_alloc_type::const_pointer const_pointer;
+      typedef typename _Key_alloc_type::reference reference;
+      typedef typename _Key_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::const_iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      multiset()
+      : _M_t() { }
+      explicit
+      multiset(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+      template<typename _InputIterator>
+        multiset(_InputIterator __first, _InputIterator __last,
+   const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a)
+        { _M_t._M_insert_equal(__first, __last); }
+      multiset(const multiset& __x)
+      : _M_t(__x._M_t) { }
+      multiset&
+      operator=(const multiset& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+      value_compare
+      value_comp() const
+      { return _M_t.key_comp(); }
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+      iterator
+      begin() const
+      { return _M_t.begin(); }
+      iterator
+      end() const
+      { return _M_t.end(); }
+      reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+      reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+      bool
+      empty() const
+      { return _M_t.empty(); }
+      size_type
+      size() const
+      { return _M_t.size(); }
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+      void
+      swap(multiset& __x)
+      { _M_t.swap(__x._M_t); }
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+      iterator
+      insert(const_iterator __position, const value_type& __x)
+      { return _M_t._M_insert_equal_(__position, __x); }
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+      void
+      clear()
+      { _M_t.clear(); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+      template<typename _K1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multiset<_K1, _C1, _A1>&,
+     const multiset<_K1, _C1, _A1>&);
+      template<typename _K1, typename _C1, typename _A1>
+        friend bool
+        operator< (const multiset<_K1, _C1, _A1>&,
+     const multiset<_K1, _C1, _A1>&);
+    };
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
+        const multiset<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
+       const multiset<_Key, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
+        const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
+       const multiset<_Key,_Compare,_Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
+        const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
+        const multiset<_Key, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Key, typename _Compare, typename _Alloc>
+    inline void
+    swap(multiset<_Key, _Compare, _Alloc>& __x,
+  multiset<_Key, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+}
+namespace boost
+{
+    template<class T>
+    struct is_std_map
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Ty
+      , class Pr
+      , class Alloc
+    >
+    struct is_std_map< ::std::map<Kty,Ty,Pr,Alloc> >
+        : boost::mpl::true_
+    {};
+    template<class T>
+    struct is_std_multimap
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Ty
+      , class Pr
+      , class Alloc
+    >
+    struct is_std_multimap< ::std::multimap<Kty,Ty,Pr,Alloc> >
+        : boost::mpl::true_
+    {};
+}
+namespace boost
+{
+    template<class T>
+    struct is_std_set
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Pr
+      , class Alloc
+    >
+    struct is_std_set< ::std::set<Kty,Pr,Alloc> >
+        : boost::mpl::true_
+    {};
+    template<class T>
+    struct is_std_multiset
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Pr
+      , class Alloc
+    >
+    struct is_std_multiset< ::std::multiset<Kty,Pr,Alloc> >
+        : boost::mpl::true_
+    {};
+}
+namespace __gnu_cxx
+{
+    template<
+        class Kty
+      , class Ty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    class hash_map;
+    template<
+        class Kty
+      , class Ty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    class hash_multimap;
+}
+namespace boost
+{
+    template<class T>
+    struct is_std_hash_map
+        : boost::mpl::false_
+    {};
+    template<class T>
+    struct is_std_hash_multimap
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Ty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    struct is_std_hash_map< ::__gnu_cxx::hash_map<Kty,Ty,Hash,Cmp,Alloc> >
+        : boost::mpl::true_
+    {};
+    template<
+        class Kty
+      , class Ty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    struct is_std_hash_multimap< ::__gnu_cxx::hash_multimap<Kty,Ty,Hash,Cmp,Alloc> >
+        : boost::mpl::true_
+    {};
+}
+namespace __gnu_cxx
+{
+    template<
+        class Kty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    class hash_set;
+    template<
+        class Kty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    class hash_multiset;
+}
+namespace boost
+{
+    template<class T>
+    struct is_std_hash_set
+        : boost::mpl::false_
+    {};
+    template<class T>
+    struct is_std_hash_multiset
+        : boost::mpl::false_
+    {};
+    template<
+        class Kty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    struct is_std_hash_set< ::__gnu_cxx::hash_set<Kty,Hash,Cmp,Alloc> >
+        : boost::mpl::true_
+    {};
+    template<
+        class Kty
+      , class Hash
+      , class Cmp
+      , class Alloc
+    >
+    struct is_std_hash_multiset< ::__gnu_cxx::hash_multiset<Kty,Hash,Cmp,Alloc> >
+        : boost::mpl::true_
+    {};
+}
+namespace boost
+{
+    template<typename T>
+    struct has_find
+        : boost::mpl::or_<
+            boost::mpl::or_<
+                is_std_map<T>
+              , is_std_multimap<T>
+              , is_std_set<T>
+              , is_std_multiset<T>
+            >
+          , boost::mpl::or_<
+                is_std_hash_map<T>
+              , is_std_hash_multimap<T>
+              , is_std_hash_set<T>
+              , is_std_hash_multiset<T>
+          >
+        >
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_lower_bound
+        : boost::mpl::or_<
+            boost::mpl::or_<
+                is_std_map<T>
+              , is_std_multimap<T>
+              , is_std_set<T>
+              , is_std_multiset<T>
+            >
+          , boost::mpl::or_<
+                is_std_hash_map<T>
+              , is_std_hash_multimap<T>
+              , is_std_hash_set<T>
+              , is_std_hash_multiset<T>
+          >
+        >
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_upper_bound
+        : boost::mpl::or_<
+            boost::mpl::or_<
+                is_std_map<T>
+              , is_std_multimap<T>
+              , is_std_set<T>
+              , is_std_multiset<T>
+            >
+          , boost::mpl::or_<
+                is_std_hash_map<T>
+              , is_std_hash_multimap<T>
+              , is_std_hash_set<T>
+              , is_std_hash_multiset<T>
+          >
+        >
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_equal_range
+        : boost::mpl::or_<
+            boost::mpl::or_<
+                is_std_map<T>
+              , is_std_multimap<T>
+              , is_std_set<T>
+              , is_std_multiset<T>
+            >
+          , boost::mpl::or_<
+                is_std_hash_map<T>
+              , is_std_hash_multimap<T>
+              , is_std_hash_set<T>
+              , is_std_hash_multiset<T>
+          >
+        >
+    {
+    };
+}
+namespace boost { namespace phoenix {
+namespace detail
+{
+  template<typename T>
+  struct decay_array
+  {
+      typedef T type;
+  };
+  template<typename T, int N>
+  struct decay_array<T[N]>
+  {
+      typedef T* type;
+  };
+}
+}}
+namespace boost { namespace phoenix {
+namespace impl
+{
+    struct find
+    {
+        template<class R, class T>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& x, mpl::true_) const
+        {
+            return r.find(x);
+        }
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& x, mpl::false_) const
+        {
+            return std::find(detail::begin_(r), detail::end_(r), x);
+        }
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& x) const
+        {
+            return execute(r, x, has_find<R>());
+        }
+    };
+    struct find_if
+    {
+        template<class R, class P>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::find_if(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct find_end
+    {
+        template<class R, class R2, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class R2>
+        typename result<R, R2>::type operator()(R& r, R2& r2) const
+        {
+            return std::find_end(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                );
+        }
+        template<class R, class R2, class P>
+        typename result<R, R2, P>::type operator()(R& r, R2& r2, P p) const
+        {
+            return std::find_end(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                , p
+                );
+        }
+    };
+    struct find_first_of
+    {
+        template<class R, class R2, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class R2>
+        typename result<R, R2>::type operator()(R& r, R2& r2) const
+        {
+            return std::find_first_of(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                );
+        }
+        template<class R, class R2, class P>
+        typename result<R, R2, P>::type operator()(R& r, R2& r2, P p) const
+        {
+            return std::find_first_of(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                , p
+                );
+        }
+    };
+    struct adjacent_find
+    {
+        template<class R, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R>
+        typename result<R>::type operator()(R& r) const
+        {
+            return std::adjacent_find(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::adjacent_find(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct count
+    {
+        template<class R, class T>
+        struct result : range_difference<R>
+        {};
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& x) const
+        {
+            return std::count(detail::begin_(r), detail::end_(r), x);
+        }
+    };
+    struct count_if
+    {
+        template<class R, class P>
+        struct result : range_difference<R>
+        {};
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::count_if(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct distance
+    {
+        template<class R>
+        struct result : range_difference<R>
+        {};
+        template<class R>
+        typename result<R>::type operator()(R& r) const
+        {
+            return std::distance(detail::begin_(r), detail::end_(r));
+        }
+    };
+    struct equal
+    {
+        template<class R, class I, class P = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R, class I>
+        bool operator()(R& r, I i) const
+        {
+            return std::equal(detail::begin_(r), detail::end_(r), i);
+        }
+        template<class R, class I, class P>
+        bool operator()(R& r, I i, P p) const
+        {
+            return std::equal(detail::begin_(r), detail::end_(r), i, p);
+        }
+    };
+    struct search
+    {
+        template<class R, class R2, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class R2>
+        typename result<R, R2>::type operator()(R& r, R2& r2) const
+        {
+            return std::search(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                );
+        }
+        template<class R, class R2, class P>
+        typename result<R, R2, P>::type operator()(R& r, R2& r2, P p) const
+        {
+            return std::search(
+                detail::begin_(r)
+                , detail::end_(r)
+                , detail::begin_(r2)
+                , detail::end_(r2)
+                , p
+                );
+        }
+    };
+    struct lower_bound
+    {
+        template<class R, class T, class C = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::true_) const
+        {
+            return r.lower_bound(val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::false_) const
+        {
+            return std::lower_bound(detail::begin_(r), detail::end_(r), val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& val) const
+        {
+            return execute(r, val, has_lower_bound<R>());
+        }
+        template<class R, class T, class C>
+        typename result<R, T>::type operator()(R& r, T const& val, C c) const
+        {
+            return std::lower_bound(detail::begin_(r), detail::end_(r), val, c);
+        }
+    };
+    struct upper_bound
+    {
+        template<class R, class T, class C = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::true_) const
+        {
+            return r.upper_bound(val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::false_) const
+        {
+            return std::upper_bound(detail::begin_(r), detail::end_(r), val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& val) const
+        {
+            return execute(r, val, has_upper_bound<R>());
+        }
+        template<class R, class T, class C>
+        typename result<R, T>::type operator()(R& r, T const& val, C c) const
+        {
+            return std::upper_bound(detail::begin_(r), detail::end_(r), val, c);
+        }
+    };
+    struct equal_range
+    {
+        template<class R, class T, class C = void>
+        struct result
+        {
+            typedef std::pair<
+                typename range_result_iterator<R>::type
+                , typename range_result_iterator<R>::type
+            > type;
+        };
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::true_) const
+        {
+            return r.equal_range(val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& val, mpl::false_) const
+        {
+            return std::equal_range(detail::begin_(r), detail::end_(r), val);
+        }
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& val) const
+        {
+            return execute(r, val, has_equal_range<R>());
+        }
+        template<class R, class T, class C>
+        typename result<R, T>::type operator()(R& r, T const& val, C c) const
+        {
+            return std::equal_range(detail::begin_(r), detail::end_(r), val, c);
+        }
+    };
+    struct mismatch
+    {
+        template<class R, class I, class P = void>
+        struct result
+        {
+            typedef std::pair<
+                typename range_result_iterator<R>::type
+                , typename detail::decay_array<I>::type
+            > type;
+        };
+        template<class R, class I>
+        typename result<R, I>::type operator()(R& r, I i) const
+        {
+            return std::mismatch(detail::begin_(r), detail::end_(r), i);
+        }
+        template<class R, class I, class P>
+        typename result<R, I, P>::type operator()(R& r, I i, P p) const
+        {
+            return std::mismatch(detail::begin_(r), detail::end_(r), i, p);
+        }
+    };
+    struct binary_search
+    {
+        template<class R, class T, class C = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R, class T>
+        bool operator()(R& r, T const& val) const
+        {
+            return std::binary_search(detail::begin_(r), detail::end_(r), val);
+        }
+        template<class R, class T, class C>
+        bool operator()(R& r, T const& val, C c) const
+        {
+            return std::binary_search(detail::begin_(r), detail::end_(r), val, c);
+        }
+    };
+    struct includes
+    {
+        template<class R1, class R2, class C = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R1, class R2>
+        bool operator()(R1& r1, R2& r2) const
+        {
+            return std::includes(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                );
+        }
+        template<class R1, class R2, class C>
+        bool operator()(R1& r1, R2& r2, C c) const
+        {
+            return std::includes(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , c
+                );
+        }
+    };
+    struct min_element
+    {
+        template<class R, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R>
+        typename result<R>::type operator()(R& r) const
+        {
+            return std::min_element(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::min_element(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct max_element
+    {
+        template<class R, class P = void>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R>
+        typename result<R>::type operator()(R& r) const
+        {
+            return std::max_element(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::max_element(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct lexicographical_compare
+    {
+        template<class R1, class R2, class P = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R1, class R2>
+        typename result<R1, R2>::type operator()(R1& r1, R2& r2) const
+        {
+            return std::lexicographical_compare(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                );
+        }
+        template<class R1, class R2, class P>
+        typename result<R1, R2>::type operator()(R1& r1, R2& r2, P p) const
+        {
+            return std::lexicographical_compare(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , p
+                );
+        }
+    };
+}
+function<impl::find> const find = impl::find();
+function<impl::find_if> const find_if = impl::find_if();
+function<impl::find_end> const find_end = impl::find_end();
+function<impl::find_first_of> const find_first_of = impl::find_first_of();
+function<impl::adjacent_find> const adjacent_find = impl::adjacent_find();
+function<impl::count> const count = impl::count();
+function<impl::count_if> const count_if = impl::count_if();
+function<impl::distance> const distance = impl::distance();
+function<impl::equal> const equal = impl::equal();
+function<impl::search> const search = impl::search();
+function<impl::lower_bound> const lower_bound = impl::lower_bound();
+function<impl::upper_bound> const upper_bound = impl::upper_bound();
+function<impl::equal_range> const equal_range = impl::equal_range();
+function<impl::mismatch> const mismatch = impl::mismatch();
+function<impl::binary_search> const binary_search = impl::binary_search();
+function<impl::includes> const includes = impl::includes();
+function<impl::min_element> const min_element = impl::min_element();
+function<impl::max_element> const max_element = impl::max_element();
+function<impl::lexicographical_compare> const lexicographical_compare = impl::lexicographical_compare();
+}}
+namespace boost
+{
+    template<class T>
+    struct is_std_list
+        : boost::mpl::false_
+    {};
+    template<
+        class Ty
+      , class Alloc
+    >
+    struct is_std_list< ::std::list<Ty,Alloc> >
+        : boost::mpl::true_
+    {};
+}
+namespace boost
+{
+    template<typename T>
+    struct has_sort
+        : is_std_list<T>
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_remove
+        : is_std_list<T>
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_remove_if
+        : is_std_list<T>
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_unique
+        : is_std_list<T>
+    {
+    };
+}
+namespace boost
+{
+    template<typename T>
+    struct has_reverse
+        : is_std_list<T>
+    {
+    };
+}
+namespace boost { namespace phoenix { namespace impl
+{
+    struct swap
+    {
+        template <class A, class B>
+        struct result
+        {
+            typedef void type;
+        };
+        template <class A, class B>
+        void operator()(A& a, B& b) const
+        {
+            using std::swap;
+            swap(a, b);
+        }
+    };
+    struct copy
+    {
+        template<class R, class I>
+        struct result
+            : detail::decay_array<I>
+        {};
+        template<class R, class I>
+        typename result<R,I>::type
+        operator()(R& r, I i) const
+        {
+            return std::copy(detail::begin_(r), detail::end_(r), i);
+        }
+    };
+    struct copy_backward
+    {
+        template<class R, class I>
+        struct result
+        {
+            typedef I type;
+        };
+        template<class R, class I>
+        I operator()(R& r, I i) const
+        {
+            return std::copy_backward(detail::begin_(r), detail::end_(r), i);
+        }
+    };
+    struct transform
+    {
+        template<class R, class OutorI1, class ForOut, class BinF = void>
+        struct result
+            : detail::decay_array<
+            typename mpl::if_<is_void<BinF>, OutorI1, ForOut>::type>
+        {
+        };
+        template<class R, class O, class F>
+        typename result<R,O,F>::type
+        operator()(R& r, O o, F f) const
+        {
+            return std::transform(detail::begin_(r), detail::end_(r), o, f);
+        }
+        template<class R, class I, class O, class F>
+        typename result<R,I,O,F>::type
+        operator()(R& r, I i, O o, F f) const
+        {
+            return std::transform(detail::begin_(r), detail::end_(r), i, o, f);
+        }
+    };
+    struct replace
+    {
+        template<class R, class T, class T2>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class T>
+        void operator()(R& r, T const& what, T const& with) const
+        {
+            std::replace(detail::begin_(r), detail::end_(r), what, with);
+        }
+    };
+    struct replace_if
+    {
+        template<class R, class P, class T>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class P, class T>
+        void operator()(R& r, P p, T const& with) const
+        {
+            std::replace_if(detail::begin_(r), detail::end_(r), p, with);
+        }
+    };
+    struct replace_copy
+    {
+        template<class R, class O, class T, class T2>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O, class T>
+        typename result<R,O,T,T>::type
+        operator()(R& r, O o, T const& what, T const& with) const
+        {
+            return std::replace_copy(detail::begin_(r), detail::end_(r), o, what, with);
+        }
+    };
+    struct replace_copy_if
+    {
+        template<class R, class O, class P, class T>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O, class P, class T>
+        typename result<R,O,P,T>::type
+        operator()(R& r, O o, P p, T const& with) const
+        {
+            return std::replace_copy_if(detail::begin_(r), detail::end_(r), o, p, with);
+        }
+    };
+    struct fill
+    {
+        template<class R, class T>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class T>
+        void operator()(R& r, T const& x) const
+        {
+            std::fill(detail::begin_(r), detail::end_(r), x);
+        }
+    };
+    struct fill_n
+    {
+        template<class R, class N, class T>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class N, class T>
+        void operator()(R& r, N n, T const& x) const
+        {
+            std::fill_n(detail::begin_(r), n, x);
+        }
+    };
+    struct generate
+    {
+        template<class R, class G>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class G>
+        void operator()(R& r, G g) const
+        {
+            std::generate(detail::begin_(r), detail::end_(r), g);
+        }
+    };
+    struct generate_n
+    {
+        template<class R, class N, class G>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class N, class G>
+        void operator()(R& r, N n, G g) const
+        {
+            std::generate_n(detail::begin_(r), n, g);
+        }
+    };
+    struct remove
+    {
+        template<class R, class T>
+        struct result : range_result_iterator<R>
+        {
+        };
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& x, mpl::true_) const
+        {
+            r.remove(x);
+            return detail::end_(r);
+        }
+        template<class R, class T>
+        typename result<R, T>::type execute(R& r, T const& x, mpl::false_) const
+        {
+            return std::remove(detail::begin_(r), detail::end_(r), x);
+        }
+        template<class R, class T>
+        typename result<R, T>::type operator()(R& r, T const& x) const
+        {
+            return execute(r, x, has_remove<R>());
+        }
+    };
+    struct remove_if
+    {
+        template<class R, class P>
+        struct result : range_result_iterator<R>
+        {
+        };
+        template<class R, class P>
+        typename result<R, P>::type execute(R& r, P p, mpl::true_) const
+        {
+            r.remove_if(p);
+            return detail::end_(r);
+        }
+        template<class R, class P>
+        typename result<R, P>::type execute(R& r, P p, mpl::false_) const
+        {
+            return std::remove_if(detail::begin_(r), detail::end_(r), p);
+        }
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return execute(r, p, has_remove_if<R>());
+        }
+    };
+    struct remove_copy
+    {
+        template<class R, class O, class T>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O, class T>
+        typename result<R,O,T>::type
+        operator()(R& r, O o, T const& x) const
+        {
+            return std::remove_copy(detail::begin_(r), detail::end_(r), o, x);
+        }
+    };
+    struct remove_copy_if
+    {
+        template<class R, class O, class P>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O, class P>
+        typename result<R,O,P>::type
+        operator()(R& r, O o, P p) const
+        {
+            return std::remove_copy_if(detail::begin_(r), detail::end_(r), o, p);
+        }
+    };
+    struct unique
+    {
+        template<class R, class P = void>
+        struct result : range_result_iterator<R>
+        {
+        };
+        template<class R>
+        typename result<R>::type execute(R& r, mpl::true_) const
+        {
+            r.unique();
+            return detail::end_(r);
+        }
+        template<class R>
+        typename result<R>::type execute(R& r, mpl::false_) const
+        {
+            return std::unique(detail::begin_(r), detail::end_(r));
+        }
+        template<class R>
+        typename result<R>::type operator()(R& r) const
+        {
+            return execute(r, has_unique<R>());
+        }
+        template<class R, class P>
+        typename result<R>::type execute(R& r, P p, mpl::true_) const
+        {
+            r.unique(p);
+            return detail::end_(r);
+        }
+        template<class R, class P>
+        typename result<R, P>::type execute(R& r, P p, mpl::false_) const
+        {
+            return std::unique(detail::begin_(r), detail::end_(r), p);
+        }
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return execute(r, p, has_unique<R>());
+        }
+    };
+    struct unique_copy
+    {
+        template<class R, class O, class P = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O>
+        typename result<R, O>::type operator()(R& r, O o) const
+        {
+            return std::unique_copy(
+                detail::begin_(r)
+                , detail::end_(r)
+                , o
+                );
+        }
+        template<class R, class O, class P>
+        typename result<R, O, P>::type operator()(R& r, O o, P p) const
+        {
+            return std::unique_copy(
+                detail::begin_(r)
+                , detail::end_(r)
+                , o
+                , p
+                );
+        }
+    };
+    struct reverse
+    {
+        template<class R>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void execute(R& r, mpl::true_) const
+        {
+            r.reverse();
+        }
+        template<class R>
+        void execute(R& r, mpl::false_) const
+        {
+            std::reverse(detail::begin_(r), detail::end_(r));
+        }
+        template<class R>
+        void operator()(R& r) const
+        {
+            execute(r, has_reverse<R>());
+        }
+    };
+    struct reverse_copy
+    {
+        template<class R, class O>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class O>
+        typename result<R, O>::type operator()(R& r, O o) const
+        {
+            return std::reverse_copy(
+                detail::begin_(r)
+                , detail::end_(r)
+                , o
+                );
+        }
+    };
+    struct rotate
+    {
+        template<class R, class M>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class M>
+        void operator()(R& r, M m) const
+        {
+            std::rotate(
+                detail::begin_(r)
+                , m
+                , detail::end_(r)
+                );
+        }
+    };
+    struct rotate_copy
+    {
+        template<class R, class M, class O>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R, class M, class O>
+        typename result<R, M, O>::type operator()(R& r, M m, O o) const
+        {
+            return std::rotate_copy(
+                detail::begin_(r)
+                , m
+                , detail::end_(r)
+                , o
+                );
+        }
+    };
+    struct random_shuffle
+    {
+        template<class R, class G = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            return std::random_shuffle(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class G>
+        void operator()(R& r, G g) const
+        {
+            return std::random_shuffle(detail::begin_(r), detail::end_(r), g);
+        }
+    };
+    struct partition
+    {
+        template<class R, class P>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::partition(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct stable_partition
+    {
+        template<class R, class P>
+        struct result : range_result_iterator<R>
+        {};
+        template<class R, class P>
+        typename result<R, P>::type operator()(R& r, P p) const
+        {
+            return std::stable_partition(detail::begin_(r), detail::end_(r), p);
+        }
+    };
+    struct sort
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void execute(R& r, mpl::true_) const
+        {
+            r.sort();
+        }
+        template<class R>
+        void execute(R& r, mpl::false_) const
+        {
+            std::sort(detail::begin_(r), detail::end_(r));
+        }
+        template<class R>
+        void operator()(R& r) const
+        {
+            execute(r, has_sort<R>());
+        }
+        template<class R, class C>
+        void execute(R& r, C c, mpl::true_) const
+        {
+            r.sort(c);
+        }
+        template<class R, class C>
+        void execute(R& r, C c, mpl::false_) const
+        {
+            std::sort(detail::begin_(r), detail::end_(r), c);
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            execute(r, c, has_sort<R>());
+        }
+    };
+    struct stable_sort
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            std::stable_sort(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            std::stable_sort(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct partial_sort
+    {
+        template<class R, class M, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class M>
+        void operator()(R& r, M m) const
+        {
+            std::partial_sort(detail::begin_(r), m, detail::end_(r));
+        }
+        template<class R, class M, class C>
+        void operator()(R& r, M m, C c) const
+        {
+            std::partial_sort(detail::begin_(r), m, detail::end_(r), c);
+        }
+    };
+    struct partial_sort_copy
+    {
+        template<class R1, class R2, class C = void>
+        struct result : range_result_iterator<R2>
+        {};
+        template<class R1, class R2>
+        typename result<R1, R2>::type operator()(R1& r1, R2& r2) const
+        {
+            return std::partial_sort_copy(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                );
+        }
+        template<class R1, class R2, class C>
+        typename result<R1, R2>::type operator()(R1& r1, R2& r2, C c) const
+        {
+            return std::partial_sort_copy(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , c
+                );
+        }
+    };
+    struct nth_element
+    {
+        template<class R, class N, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class N>
+        void operator()(R& r, N n) const
+        {
+            return std::nth_element(detail::begin_(r), n, detail::end_(r));
+        }
+        template<class R, class N, class C>
+        void operator()(R& r, N n, C c) const
+        {
+            return std::nth_element(detail::begin_(r), n, detail::end_(r), c);
+        }
+    };
+    struct merge
+    {
+        template<class R1, class R2, class O, class C = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R1, class R2, class O>
+        typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const
+        {
+            return std::merge(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                );
+        }
+        template<class R1, class R2, class O, class C>
+        typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const
+        {
+            return std::merge(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                , c
+                );
+        }
+    };
+    struct inplace_merge
+    {
+        template<class R, class M, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R, class M>
+        void operator()(R& r, M m) const
+        {
+            return std::inplace_merge(detail::begin_(r), m, detail::end_(r));
+        }
+        template<class R, class M, class C>
+        void operator()(R& r, M m, C c) const
+        {
+            return std::inplace_merge(detail::begin_(r), m, detail::end_(r), c);
+        }
+    };
+    struct next_permutation
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R>
+        bool operator()(R& r) const
+        {
+            return std::next_permutation(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        bool operator()(R& r, C c) const
+        {
+            return std::next_permutation(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct prev_permutation
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef bool type;
+        };
+        template<class R>
+        bool operator()(R& r) const
+        {
+            return std::prev_permutation(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        bool operator()(R& r, C c) const
+        {
+            return std::prev_permutation(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct inner_product
+    {
+        template<class R, class I, class T, class C1 = void, class C2 = void>
+        struct result
+        {
+            typedef T type;
+        };
+        template<class R, class I, class T>
+        typename result<R,I,T>::type
+        operator()(R& r, I i, T t) const
+        {
+            return std::inner_product(
+                detail::begin_(r), detail::end_(r), i, t);
+        }
+        template<class R, class I, class T, class C1, class C2>
+        typename result<R,I,T,C1,C2>::type
+        operator()(R& r, I i, T t, C1 c1, C2 c2) const
+        {
+            return std::inner_product(
+                detail::begin_(r), detail::end_(r), i,
+                t, c1, c2);
+        }
+    };
+    struct partial_sum
+    {
+        template<class R, class I, class C = void>
+        struct result
+            : detail::decay_array<I>
+        {};
+        template<class R, class I>
+        typename result<R,I>::type
+        operator()(R& r, I i) const
+        {
+            return std::partial_sum(
+                detail::begin_(r), detail::end_(r), i);
+        }
+        template<class R, class I, class C>
+        typename result<R,I,C>::type
+        operator()(R& r, I i, C c) const
+        {
+            return std::partial_sum(
+                detail::begin_(r), detail::end_(r), i, c);
+        }
+    };
+    struct adjacent_difference
+    {
+        template<class R, class I, class C = void>
+        struct result
+            : detail::decay_array<I>
+        {};
+        template<class R, class I>
+        typename result<R,I>::type
+        operator()(R& r, I i) const
+        {
+            return std::adjacent_difference(
+                detail::begin_(r), detail::end_(r), i);
+        }
+        template<class R, class I, class C>
+        typename result<R,I,C>::type
+        operator()(R& r, I i, C c) const
+        {
+            return std::adjacent_difference(
+                detail::begin_(r), detail::end_(r), i, c);
+        }
+    };
+    struct push_heap
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            std::push_heap(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            std::push_heap(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct pop_heap
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            std::pop_heap(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            std::pop_heap(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct make_heap
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            std::make_heap(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            std::make_heap(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct sort_heap
+    {
+        template<class R, class C = void>
+        struct result
+        {
+            typedef void type;
+        };
+        template<class R>
+        void operator()(R& r) const
+        {
+            std::sort_heap(detail::begin_(r), detail::end_(r));
+        }
+        template<class R, class C>
+        void operator()(R& r, C c) const
+        {
+            std::sort_heap(detail::begin_(r), detail::end_(r), c);
+        }
+    };
+    struct set_union
+    {
+        template<class R1, class R2, class O, class C = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R1, class R2, class O>
+        typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const
+        {
+            return std::set_union(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                );
+        }
+        template<class R1, class R2, class O, class C>
+        typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const
+        {
+            return std::set_union(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                , c
+                );
+        }
+    };
+    struct set_intersection
+    {
+        template<class R1, class R2, class O, class C = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R1, class R2, class O>
+        typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const
+        {
+            return std::set_intersection(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                );
+        }
+        template<class R1, class R2, class O, class C>
+        typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const
+        {
+            return std::set_intersection(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                , c
+                );
+        }
+    };
+    struct set_difference
+    {
+        template<class R1, class R2, class O, class C = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R1, class R2, class O>
+        typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const
+        {
+            return std::set_difference(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                );
+        }
+        template<class R1, class R2, class O, class C>
+        typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const
+        {
+            return std::set_difference(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                , c
+                );
+        }
+    };
+    struct set_symmetric_difference
+    {
+        template<class R1, class R2, class O, class C = void>
+        struct result
+            : detail::decay_array<O>
+        {};
+        template<class R1, class R2, class O>
+        typename result<R1, R2, O>::type operator()(R1& r1, R2& r2, O o) const
+        {
+            return std::set_symmetric_difference(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                );
+        }
+        template<class R1, class R2, class O, class C>
+        typename result<R1, R2, O, C>::type operator()(R1& r1, R2& r2, O o, C c) const
+        {
+            return std::set_symmetric_difference(
+                detail::begin_(r1), detail::end_(r1)
+                , detail::begin_(r2), detail::end_(r2)
+                , o
+                , c
+                );
+        }
+    };
+}}}
+namespace boost { namespace phoenix
+{
+    function<impl::swap> const swap = impl::swap();
+    function<impl::copy> const copy = impl::copy();
+    function<impl::copy_backward> const copy_backward = impl::copy_backward();
+    function<impl::transform> const transform = impl::transform();
+    function<impl::replace> const replace = impl::replace();
+    function<impl::replace_if> const replace_if = impl::replace_if();
+    function<impl::replace_copy> const replace_copy = impl::replace_copy();
+    function<impl::replace_copy_if> const replace_copy_if = impl::replace_copy_if();
+    function<impl::fill> const fill = impl::fill();
+    function<impl::fill_n> const fill_n = impl::fill_n();
+    function<impl::generate> const generate = impl::generate();
+    function<impl::generate_n> const generate_n = impl::generate_n();
+    function<impl::remove> const remove = impl::remove();
+    function<impl::remove_if> const remove_if = impl::remove_if();
+    function<impl::remove_copy> const remove_copy = impl::remove_copy();
+    function<impl::remove_copy_if> const remove_copy_if = impl::remove_copy_if();
+    function<impl::unique> const unique = impl::unique();
+    function<impl::unique_copy> const unique_copy = impl::unique_copy();
+    function<impl::reverse> const reverse = impl::reverse();
+    function<impl::reverse_copy> const reverse_copy = impl::reverse_copy();
+    function<impl::rotate> const rotate = impl::rotate();
+    function<impl::rotate_copy> const rotate_copy = impl::rotate_copy();
+    function<impl::random_shuffle> const random_shuffle = impl::random_shuffle();
+    function<impl::partition> const partition = impl::partition();
+    function<impl::stable_partition> const stable_partition = impl::stable_partition();
+    function<impl::sort> const sort = impl::sort();
+    function<impl::stable_sort> const stable_sort = impl::stable_sort();
+    function<impl::partial_sort> const partial_sort = impl::partial_sort();
+    function<impl::partial_sort_copy> const partial_sort_copy = impl::partial_sort_copy();
+    function<impl::nth_element> const nth_element = impl::nth_element();
+    function<impl::merge> const merge = impl::merge();
+    function<impl::inplace_merge> const inplace_merge = impl::inplace_merge();
+    function<impl::next_permutation> const next_permutation = impl::next_permutation();
+    function<impl::prev_permutation> const prev_permutation = impl::prev_permutation();
+    function<impl::inner_product> const inner_product = impl::inner_product();
+    function<impl::partial_sum> const partial_sum = impl::partial_sum();
+    function<impl::adjacent_difference> const adjacent_difference = impl::adjacent_difference();
+    function<impl::push_heap> const push_heap = impl::push_heap();
+    function<impl::pop_heap> const pop_heap = impl::pop_heap();
+    function<impl::make_heap> const make_heap = impl::make_heap();
+    function<impl::sort_heap> const sort_heap = impl::sort_heap();
+    function<impl::set_union> const set_union = impl::set_union();
+    function<impl::set_intersection> const set_intersection = impl::set_intersection();
+    function<impl::set_difference> const set_difference = impl::set_difference();
+    function<impl::set_symmetric_difference> const set_symmetric_difference = impl::set_symmetric_difference();
+}}
+namespace boost { namespace phoenix { namespace stl
+{
+    template <typename C> struct allocator_type_of { typedef typename C::allocator_type type; };
+    template <typename C> struct const_iterator_of { typedef typename C::const_iterator type; };
+    template <typename C> struct const_reference_of { typedef typename C::const_reference type; };
+    template <typename C> struct const_reverse_iterator_of { typedef typename C::const_reverse_iterator type; };
+    template <typename C> struct container_type_of { typedef typename C::container_type type; };
+    template <typename C> struct data_type_of { typedef typename C::data_type type; };
+    template <typename C> struct iterator_of { typedef typename C::iterator type; };
+    template <typename C> struct key_compare_of { typedef typename C::key_compare type; };
+    template <typename C> struct key_type_of { typedef typename C::key_type type; };
+    template <typename C> struct reference_of { typedef typename C::reference type; };
+    template <typename C> struct reverse_iterator_of { typedef typename C::reverse_iterator type; };
+    template <typename C> struct size_type_of { typedef typename C::size_type type; };
+    template <typename C> struct value_compare_of { typedef typename C::value_compare type; };
+    template <typename C> struct value_type_of { typedef typename C::value_type type; };
+    template <typename C>
+    struct const_qualified_reference_of
+    {
+        typedef typename
+            boost::mpl::eval_if<
+                boost::is_const<C>
+              , const_reference_of<C>
+              , reference_of<C>
+            >::type
+        type;
+    };
+    template <typename C>
+    struct const_qualified_iterator_of
+    {
+        typedef typename
+            boost::mpl::eval_if<
+                boost::is_const<C>
+              , const_iterator_of<C>
+              , iterator_of<C>
+            >::type
+        type;
+    };
+    template <typename C>
+    struct const_qualified_reverse_iterator_of
+    {
+        typedef typename
+            boost::mpl::eval_if<
+                boost::is_const<C>
+              , const_reverse_iterator_of<C>
+              , reverse_iterator_of<C>
+            >::type
+        type;
+    };
+    namespace stl_impl
+    {
+        struct one { char a[1]; };
+        struct two { char a[2]; };
+        template <typename C>
+        one has_mapped_type(typename C::mapped_type(*)());
+        template <typename C>
+        two has_mapped_type(...);
+    }
+    template <typename C>
+    struct has_mapped_type
+        : boost::mpl::bool_<
+            sizeof(stl_impl::has_mapped_type<C>(0)) == sizeof(stl_impl::one)
+        >
+    {};
+    namespace stl_impl
+    {
+        template<class A, class B>
+        one map_insert_returns_pair_check(std::pair<A,B> const&);
+        template <typename T>
+        two map_insert_returns_pair_check(T const&);
+        template <typename C>
+        struct map_insert_returns_pair
+        {
+            static typename C::value_type const& get;
+            static const int value = sizeof( map_insert_returns_pair_check(((C*)0)->insert(get)))
+                                                                         ;
+            typedef boost::mpl::bool_<value == sizeof(one)> type;
+        };
+    }
+    template <typename C>
+    struct map_insert_returns_pair
+        : stl_impl::map_insert_returns_pair<C>::type {};
+}}}
+namespace boost { namespace phoenix
+{
+    namespace stl
+    {
+        struct assign
+        {
+            template <
+                typename C
+              , typename Arg1 = fusion::void_
+              , typename Arg2 = fusion::void_
+              , typename Arg3 = fusion::void_
+            >
+            struct result
+            {
+                typedef typename add_reference<C>::type type;
+            };
+            template <typename C, typename Arg1>
+            C& operator()(C& c, Arg1 const& arg1) const
+            {
+                c.assign(arg1);
+                return c;
+            }
+            template <typename C, typename Arg1, typename Arg2>
+            C& operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+            {
+                c.assign(arg1, arg2);
+                return c;
+            }
+            template <typename C, typename Arg1, typename Arg2, typename Arg3>
+            C& operator()(
+                C& c
+              , Arg1 const& arg1
+              , Arg2 const& arg2
+              , Arg3 const& arg3) const
+            {
+                return c.assign(arg1, arg2, arg3);
+            }
+        };
+        struct at
+        {
+            template <typename C, typename Index>
+            struct result
+            {
+                typedef typename const_qualified_reference_of<C>::type type;
+            };
+            template <typename C, typename Index>
+            typename result<C, Index>::type
+            operator()(C& c, Index const& i) const
+            {
+                return c.at(i);
+            }
+        };
+        struct back
+        {
+            template <typename C>
+            struct result
+            {
+                typedef
+                    typename const_qualified_reference_of<C>::type
+                type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.back();
+            }
+        };
+        struct begin
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename const_qualified_iterator_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.begin();
+            }
+        };
+        struct capacity
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename size_type_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C const& c) const
+            {
+                return c.capacity();
+            }
+        };
+        struct clear
+        {
+            template <typename C>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C>
+            void operator()(C& c) const
+            {
+                return c.clear();
+            }
+        };
+        struct empty
+        {
+            template <typename C>
+            struct result
+            {
+                typedef bool type;
+            };
+            template <typename C>
+            bool operator()(C const& c) const
+            {
+                return c.empty();
+            }
+        };
+        struct end
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename const_qualified_iterator_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.end();
+            }
+        };
+        struct erase
+        {
+            template <typename C, typename Arg1, typename Arg2 = fusion::void_>
+            struct result
+            {
+                typedef
+                    boost::mpl::eval_if<
+                        boost::is_same<Arg1, typename iterator_of<C>::type>
+                      , boost::mpl::identity<void>
+                      , size_type_of<C>
+                    >
+                map_erase_result;
+                typedef typename
+                    boost::mpl::eval_if<
+                        has_mapped_type<C>
+                      , map_erase_result
+                      , iterator_of<C>
+                    >::type
+                type;
+            };
+            template <typename C, typename Arg1>
+            typename result<C, Arg1>::type
+            operator()(C& c, Arg1 const& arg1) const
+            {
+                return c.erase(arg1);
+            }
+            template <typename C, typename Arg1, typename Arg2>
+            typename result<C, Arg1, Arg2>::type
+            operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+            {
+                return c.erase(arg1, arg2);
+            }
+        };
+        struct front
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename const_qualified_reference_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.front();
+            }
+        };
+        struct get_allocator
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename allocator_type_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C const& c) const
+            {
+                return c.get_allocator();
+            }
+        };
+        struct insert
+        {
+            template <
+                typename C
+              , typename Arg1
+              , typename Arg2 = fusion::void_
+              , typename Arg3 = fusion::void_
+            >
+            class result
+            {
+                struct pair_iterator_bool
+                {
+                    typedef typename std::pair<typename C::iterator, bool> type;
+                };
+                typedef
+                    boost::mpl::eval_if<
+                        map_insert_returns_pair<C>
+                      , pair_iterator_bool
+                      , iterator_of<C>
+                    >
+                choice_1;
+                typedef
+                    boost::mpl::eval_if<
+                        boost::mpl::and_<
+                            boost::is_same<Arg3, fusion::void_>
+                          , boost::mpl::not_<boost::is_same<Arg1, Arg2> > >
+                      , iterator_of<C>
+                      , boost::mpl::identity<void>
+                    >
+                choice_2;
+            public:
+                typedef typename
+                    boost::mpl::eval_if<
+                        boost::is_same<Arg2, fusion::void_>
+                      , choice_1
+                      , choice_2
+                    >::type
+                type;
+            };
+            template <typename C, typename Arg1>
+            typename result<C, Arg1>::type
+            operator()(C& c, Arg1 const& arg1) const
+            {
+                return c.insert(arg1);
+            }
+            template <typename C, typename Arg1, typename Arg2>
+            typename result<C, Arg1, Arg2>::type
+            operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+            {
+                return c.insert(arg1, arg2);
+            }
+            template <typename C, typename Arg1, typename Arg2, typename Arg3>
+            typename result<C, Arg1, Arg2, Arg3>::type
+            operator()(
+                C& c, Arg1 const& arg1, Arg2 const& arg2, Arg3 const& arg3) const
+            {
+                return c.insert(arg1, arg2, arg3);
+            }
+        };
+        struct key_comp
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename key_compare_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C const& c) const
+            {
+                return c.key_comp();
+            }
+        };
+        struct max_size
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename size_type_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C const& c) const
+            {
+                return c.max_size();
+            }
+        };
+        struct pop_back
+        {
+            template <typename C>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C>
+            void operator()(C& c) const
+            {
+                return c.pop_back();
+            }
+        };
+        struct pop_front
+        {
+            template <typename C>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C>
+            void operator()(C& c) const
+            {
+                return c.pop_front();
+            }
+        };
+        struct push_back
+        {
+            template <typename C, typename Arg>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C, typename Arg>
+            void operator()(C& c, Arg const& data) const
+            {
+                return c.push_back(data);
+            }
+        };
+        struct push_front
+        {
+            template <typename C, typename Arg>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C, typename Arg>
+            void operator()(C& c, Arg const& data) const
+            {
+                return c.push_front(data);
+            }
+        };
+        struct rbegin
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename
+                    const_qualified_reverse_iterator_of<C>::type
+                type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.rbegin();
+            }
+        };
+        struct rend
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename
+                    const_qualified_reverse_iterator_of<C>::type
+                type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C& c) const
+            {
+                return c.rend();
+            }
+        };
+        struct reserve
+        {
+            template <typename C, typename Arg>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C, typename Arg>
+            void operator()(C& c, Arg const& count) const
+            {
+                return c.reserve(count);
+            }
+        };
+        struct resize
+        {
+            template <typename C, typename Arg1, typename Arg2 = fusion::void_>
+            struct result
+            {
+                typedef void type;
+            };
+            template <typename C, typename Arg1>
+            void operator()(C& c, Arg1 const& arg1) const
+            {
+                return c.resize(arg1);
+            }
+            template <typename C, typename Arg1, typename Arg2>
+            void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+            {
+                return c.resize(arg1, arg2);
+            }
+        };
+        struct size
+        {
+            template <typename C>
+            struct result
+            {
+                typedef typename size_type_of<C>::type type;
+            };
+            template <typename C>
+            typename result<C>::type
+            operator()(C const& c) const
+            {
+                return c.size();
+            }
+        };
+    struct splice
+    {
+        template <
+            typename C
+          , typename Arg1
+          , typename Arg2
+          , typename Arg3 = fusion::void_
+          , typename Arg4 = fusion::void_
+        >
+        struct result
+        {
+            typedef void type;
+        };
+        template <typename C, typename Arg1, typename Arg2>
+        void operator()(C& c, Arg1 const& arg1, Arg2& arg2) const
+        {
+            c.splice(arg1, arg2);
+        }
+        template <
+            typename C
+          , typename Arg1
+          , typename Arg2
+          , typename Arg3
+        >
+        void operator()(
+            C& c
+          , Arg1 const& arg1
+          , Arg2& arg2
+          , Arg3 const& arg3
+        ) const
+        {
+            c.splice(arg1, arg2, arg3);
+        }
+        template <
+            typename C
+          , typename Arg1
+          , typename Arg2
+          , typename Arg3
+          , typename Arg4
+        >
+        void operator()(
+            C& c
+          , Arg1 const& arg1
+          , Arg2& arg2
+          , Arg3 const& arg3
+          , Arg4 const& arg4
+        ) const
+        {
+            c.splice(arg1, arg2, arg3, arg4);
+        }
+    };
+    struct value_comp
+    {
+        template <typename C>
+        struct result
+        {
+            typedef typename value_compare_of<C>::type type;
+        };
+        template <typename C>
+        typename result<C>::type
+        operator()(C const& c) const
+        {
+            return c.value_comp();
+        }
+    };
+}
+function<stl::assign> const assign = stl::assign();
+function<stl::at> const at = stl::at();
+function<stl::back> const back = stl::back();
+function<stl::begin> const begin = stl::begin();
+function<stl::capacity> const capacity = stl::capacity();
+function<stl::clear> const clear = stl::clear();
+function<stl::empty> const empty = stl::empty();
+function<stl::end> const end = stl::end();
+function<stl::erase> const erase = stl::erase();
+function<stl::front> const front = stl::front();
+function<stl::get_allocator> const get_allocator = stl::get_allocator();
+function<stl::insert> const insert = stl::insert();
+function<stl::key_comp> const key_comp = stl::key_comp();
+function<stl::max_size> const max_size = stl::max_size();
+function<stl::pop_back> const pop_back = stl::pop_back();
+function<stl::pop_front> const pop_front = stl::pop_front();
+function<stl::push_back> const push_back = stl::push_back();
+function<stl::push_front> const push_front = stl::push_front();
+function<stl::rbegin> const rbegin = stl::rbegin();
+function<stl::rend> const rend = stl::rend();
+function<stl::reserve> const reserve = stl::reserve();
+function<stl::resize> const resize = stl::resize();
+function<stl::size> const size = stl::size();
+function<stl::splice> const splice = stl::splice();
+function<stl::value_comp> const value_comp = stl::value_comp();
+}}
+using namespace DotParser;
+namespace distinct
+{
+    namespace spirit = boost::spirit;
+    namespace standard = boost::spirit::standard;
+    namespace repo = boost::spirit::repository;
+    namespace traits
+    {
+        template <typename Tail>
+        struct distinct_spec
+          : spirit::result_of::terminal<repo::tag::distinct(Tail)>
+        {};
+        template <typename String>
+        struct char_spec
+          : spirit::result_of::terminal<spirit::tag::standard::char_(String)>
+        {};
+    };
+    template <typename Tail>
+    inline typename traits::distinct_spec<Tail>::type
+    distinct_spec(Tail const& tail)
+    {
+        return repo::qi::distinct(tail);
+    }
+    template <typename String>
+    inline typename traits::char_spec<String>::type
+    char_spec(String const& str)
+    {
+        return standard::char_(str);
+    }
+    typedef traits::char_spec<std::string>::type charset_tag_type;
+    typedef traits::distinct_spec<charset_tag_type>::type keyword_tag_type;
+    std::string const keyword_spec("0-9a-zA-Z_");
+    keyword_tag_type const keyword = distinct_spec(char_spec(keyword_spec));
+}
+namespace DotParser {
+namespace phx = boost::phoenix;
+using boost::phoenix::ref;
+using boost::phoenix::push_back;
+using boost::spirit::standard::alpha;
+using boost::spirit::standard::digit;
+using boost::spirit::standard::string;
+using boost::spirit::standard::space;
+using boost::spirit::qi::_1;
+using boost::spirit::qi::_val;
+using boost::spirit::qi::char_;
+using boost::spirit::qi::eol;
+using boost::spirit::qi::int_;
+using boost::spirit::qi::lexeme;
+using boost::spirit::qi::phrase_parse;
+using boost::spirit::qi::rule;
+using boost::spirit::qi::standard::space_type;
+using boost::spirit::repository::qi::confix;
+typedef __typeof__(boost::type_of::ensure_obj(space | confix("//", eol)[*(char_ - eol)] | confix("/*", "*/")[*(char_ - "*/")])) skipper_type;
+DotGraphParsingHelper* phelper = 0;
+template <typename Iterator, typename Skipper = space_type>
+struct DotGrammar : boost::spirit::qi::grammar<Iterator, Skipper> {
+    DotGrammar() : DotGrammar::base_type(graph) {
+        graph = -distinct::keyword["strict"][&setStrict]
+                >> (distinct::keyword["graph"][&undirectedDataStructure] | distinct::keyword["digraph"][&directedDataStructure])
+                >> -ID[&dataStructureId]
+                >> '{'
+                >> stmt_list
+                >> '}';
+        stmt_list = stmt >> -char_(';') >> -stmt_list;
+        stmt = ( (ID[&attributeId] >> '=' >> ID[&valid])[&applyAttributeList]
+                    | attr_stmt
+                    | edge_stmt
+                    | node_stmt
+                    | subgraph
+                );
+        attr_stmt = ( (distinct::keyword["graph"][ref(phelper->attributed)="graph"] >> attr_list[&applyAttributeList])[&setDataStructureAttributes]
+                    | (distinct::keyword["node"][ref(phelper->attributed)="node"] >> attr_list[&applyAttributeList])
+                    | (distinct::keyword["edge"][ref(phelper->attributed)="edge"] >> attr_list[&applyAttributeList])
+                    );
+        attr_list = '[' >> -a_list >>']';
+        a_list = (ID[&attributeId] >> -('=' >> ID[&valid]))[&insertAttributeIntoAttributeList]
+                 >> -char_(',') >> -a_list;
+        edge_stmt = (
+                        (node_id[&edgebound] | subgraph) >> edgeRHS >> -(attr_list[ref(phelper->attributed)="edge"])
+                    )[&createAttributeList][&applyAttributeList][&createPointers][&removeAttributeList];
+        edgeRHS = edgeop[&checkEdgeOperator] >> (node_id[&edgebound] | subgraph) >> -edgeRHS;
+        node_stmt = (
+                         node_id[&createData] >> -attr_list
+                     )[ref(phelper->attributed)="node"][&createAttributeList][&applyAttributeList][&setDataAttributes][&removeAttributeList];
+        node_id = ID >> -port;
+        port = (':' >> ID >> -(':' >> compass_pt))
+               | (':' >> compass_pt);
+        subgraph = -(distinct::keyword["subgraph"] >> -ID[&subDataStructureId])
+                   >> char_('{')[&createSubDataStructure][&createAttributeList]
+                   >> stmt_list
+                   >> char_('}')[&leaveSubDataStructure][&removeAttributeList];
+        compass_pt = (distinct::keyword["n"] | distinct::keyword["ne"] | distinct::keyword["e"]
+                    | distinct::keyword["se"] | distinct::keyword["s"] | distinct::keyword["sw"]
+                    | distinct::keyword["w"] | distinct::keyword["nw"]);
+        edgeop = string("->") | string("--");
+        ID = lexeme[
+                ( !(distinct::keyword["graph"] | distinct::keyword["edge"] | distinct::keyword["node"])
+                    >> char_("a-zA-Z0-9") >> *char_("a-zA-Z0-9_")
+                )
+                | (-char_('-') >> ('.' >> +digit) | (+digit >> -('.' >> *digit)))
+                | ('"' >> *(char_ - '"') >> '"')
+                | ('<' >> *(char_ - '>') >> '>')
+             ];
+    }
+    rule<Iterator, Skipper> graph;
+    rule<Iterator, std::string(), Skipper> ID;
+    rule<Iterator, Skipper> stmt_list;
+    rule<Iterator, Skipper> stmt;
+    rule<Iterator, Skipper> attr_stmt;
+    rule<Iterator, Skipper> attr_list;
+    rule<Iterator, Skipper> a_list;
+    rule<Iterator, Skipper> edge_stmt;
+    rule<Iterator, std::string(), Skipper> edgeop;
+    rule<Iterator, Skipper> edgeRHS;
+    rule<Iterator, Skipper> node_stmt;
+    rule<Iterator, std::string(), Skipper> node_id;
+    rule<Iterator, std::string(), Skipper> port;
+    rule<Iterator, Skipper> subgraph;
+    rule<Iterator, std::string(), Skipper> compass_pt;
+};
+void leaveSubDataStructure()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->leaveSubDataStructure();
+}
+void setStrict()
+{
+    KDebug(QtWarningMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 257, __PRETTY_FUNCTION__)() << "Graphviz \"strict\" keyword is not implemented.";
+}
+void undirectedDataStructure()
+{
+    for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 262, __PRETTY_FUNCTION__)() << "Create new data structure of type: Graph undirected";
+    if(!phelper->dataStructure) {
+        DataStructurePtr dataStructure = phelper->gd->addDataStructure("");
+        phelper->dataStructure = boost::static_pointer_cast<Rocs::GraphStructure>(dataStructure);
+    }
+    phelper->gd->pointerType(0)->setDirection(PointerType::Bidirectional);
+}
+void directedDataStructure()
+{
+    for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 272, __PRETTY_FUNCTION__)() << "Create new data structure of type: Graph directed";
+    if (!phelper->dataStructure) {
+        DataStructurePtr dataStructure = phelper->gd->addDataStructure("");
+        phelper->dataStructure = boost::static_pointer_cast<Rocs::GraphStructure>(dataStructure);
+    }
+    phelper->gd->pointerType(0)->setDirection(PointerType::Unidirectional);
+}
+void dataStructureId(const std::string& str)
+{
+    QString name = QString::fromStdString(str);
+    for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 283, __PRETTY_FUNCTION__)() << "Set data structure name: " << name;
+    if (!phelper->dataStructure) {
+        DataStructurePtr dataStructure = phelper->gd->addDataStructure(name);
+        phelper->dataStructure = boost::static_pointer_cast<Rocs::GraphStructure>(dataStructure);
+    }
+    phelper->dataStructure->setName(name);
+}
+void attributeId(const std::string& str)
+{
+    if (!phelper) {
+        return;
+    }
+    QString id = QString::fromStdString(str);
+    if (id.endsWith('"')) {
+        id.remove(id.length()-1, 1);
+    }
+    if (id.startsWith('"')) {
+        id.remove(0, 1);
+    }
+    phelper->attributeId = id;
+    phelper->valid.clear();
+}
+void subDataStructureId(const std::string& str)
+{
+    if (!phelper) {
+        return;
+    }
+    QString id = QString::fromStdString(str);
+    if (id.endsWith('"')) {
+        id.remove(id.length()-1, 1);
+    }
+    if (id.startsWith('"')) {
+        id.remove(0, 1);
+    }
+    phelper->setSubDataStructureId(id);
+}
+void valid(const std::string& str)
+{
+    if (!phelper) {
+        return;
+    }
+    QString id = QString::fromStdString(str);
+    if (id.endsWith('"')) {
+        id.remove(id.length()-1, 1);
+    }
+    if (id.startsWith('"')) {
+        id.remove(0, 1);
+    }
+    phelper->valid = id;
+}
+void insertAttributeIntoAttributeList()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->unprocessedAttributes.insert(phelper->attributeId, phelper->valid);
+}
+void createAttributeList()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->dataStructureAttributeStack.push_back(phelper->dataStructureAttributes);
+    phelper->dataAttributeStack.push_back(phelper->dataAttributes);
+    phelper->pointerAttributeStack.push_back(phelper->pointerAttributes);
+}
+void removeAttributeList()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->dataStructureAttributes = phelper->dataStructureAttributeStack.back();
+    phelper->dataStructureAttributeStack.pop_back();
+    phelper->dataAttributes = phelper->dataAttributeStack.back();
+    phelper->dataAttributeStack.pop_back();
+    phelper->pointerAttributes = phelper->pointerAttributeStack.back();
+    phelper->pointerAttributeStack.pop_back();
+}
+void createData(const std::string& str)
+{
+    QString id = QString::fromStdString(str);
+    if (!phelper || id.length()==0) {
+        return;
+    }
+    if (id.endsWith('"')) {
+        id.remove(id.length()-1, 1);
+    }
+    if (id.startsWith('"')) {
+        id.remove(0, 1);
+    }
+    if (!phelper->dataMap.contains(id)) {
+        phelper->createData(id);
+    }
+}
+void createSubDataStructure()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->createSubDataStructure();
+}
+void setDataStructureAttributes()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->setDataStructureAttributes();
+}
+void setDataAttributes()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->setDataAttributes();
+}
+void applyAttributeList()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->applyAttributedList();
+}
+void checkEdgeOperator(const std::string& str)
+{
+    if (!phelper) {
+        return;
+    }
+    if (((phelper->gd->pointerType(0)->direction() == PointerType::Unidirectional) && (str.compare("->") == 0)) ||
+            ((phelper->gd->pointerType(0)->direction() == PointerType::Bidirectional) && (str.compare("--") == 0)))
+    {
+        return;
+    }
+    kError() << "Error: incoherent edge direction relation" << endl;
+}
+void edgebound(const std::string& str)
+{
+    if (!phelper) {
+        return;
+    }
+    QString id = QString::fromStdString(str);
+    if (id.endsWith('"')) {
+        id.remove(id.length()-1, 1);
+    }
+    if (id.startsWith('"')) {
+        id.remove(0, 1);
+    }
+    phelper->addEdgeBound(id);
+}
+void createPointers()
+{
+    if (!phelper) {
+        return;
+    }
+    phelper->createPointers();
+}
+bool parseIntegers(const std::string& str, std::vector<int>& v)
+{
+    return phrase_parse(str.begin(), str.end(),
+        (
+            int_[phx::push_back(phx::ref(v), _1)]
+                >> *(',' >> int_[phx::push_back(phx::ref(v), _1)])
+        )
+        ,
+        space);
+}
+bool parse(const std::string& str, Document * graphDoc)
+{
+    delete phelper;
+    phelper = new DotGraphParsingHelper;
+    phelper->gd = graphDoc;
+    std::string input(str);
+    std::string::iterator iter = input.begin();
+    DotGrammar<std::string::iterator, skipper_type> r;
+    if (phrase_parse(iter, input.end(), r, space | confix("//", eol)[*(char_ - eol)] | confix("/*", "*/")[*(char_ - "*/")])) {
+        if (phelper->gd->dataStructures().length() > 0) {
+            phelper->gd->dataStructures().at(0)->setDataVisibility(false, phelper->gd->groupType());
+        }
+        for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 489, __PRETTY_FUNCTION__)() << "Complete dot file was parsed successfully.";
+        return true;
+    } else {
+        KDebug(QtWarningMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 492, __PRETTY_FUNCTION__)() << "Dot file parsing failed. Unable to parse:";
+        for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 493, __PRETTY_FUNCTION__)() << "///// FILE CONTENT BEGIN /////";
+        for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 494, __PRETTY_FUNCTION__)() << QString::fromStdString(std::string(iter, input.end()));
+        for (bool _k_kDebugDoOutput_ = !KDebug::hasNullOutputQtDebugMsg(); __builtin_expect(!!(_k_kDebugDoOutput_),0); _k_kDebugDoOutput_ = false) KDebug(QtDebugMsg, "/var/tmp/portage/kde-base/rocs-4.10.1/work/rocs-4.10.1/RocsCore/LoadSave/Plugins/dotFileFormat/DotGrammar.cpp", 495, __PRETTY_FUNCTION__)() << "///// FILE CONTENT END /////";
+    }
+    return false;
+}
+}